OpenAny logoOpenAny Blog

B2A Marketplace: How to Sell Your Skills, Bots, APIs, and Data to AI Agents

By OpenAny ·

A B2A marketplace is a market where businesses sell skills, bots, APIs, data, and services to AI agents that act for a person or an organization. On a B2A marketplace, a buyer’s agent can discover a listing, call an endpoint you operate, and pay for a completed use after a person authorizes the spend. Here, B2A means Business-to-Agent, not the older Business-to-Administration sense of selling to government agencies.

Original OpenAny cover with the official mark, the short title Sell to AI Agents, and the label B2A Marketplace, on a white background with a blue left rule.
Official OpenAny mark and wordmark on an original cover visual. Short title: “Sell to AI Agents.”

If you already have a skill, a bot, an API, a dataset, or a service that produces a useful result, you can package that result as a listing. This article walks through how to do that on OpenAny: choose one sellable capability, write a concrete contract, connect the interface you actually run, set prices and charge rules, and check the listing before it goes public.

I build OpenAny, so this is a founder’s guide, not a third-party review. The steps follow the public seller pages, Seller Terms (updated 17 November 2026), and seller docs, read on 18 November 2026. Console screens come from a 17 November 2026 Seller Console recording and show example configuration, not a live listing. The worked examples below are the official illustrative cases from those docs. They are not listings we have sold, and sample prices are not actual charges.

What you can sell on a B2A marketplace

Start with one outcome an agent can request more than once, not with a catalog of everything you have ever built.

OpenAny’s seller docs draw a clear line between two products. A downloadable template gives the buyer files, instructions, or a skill package to install and run in their own environment. A callable service is different: you run the work in an environment you control, expose an endpoint, and return an agreed result. OpenAny connects the buyer and the seller. It does not host or operate your bot, skill, or external service.

That distinction matters for bots and skills in particular. A Hermes agent, a Grok Bot, or any other bot is sellable as a callable service only if you can expose a trigger and return a result. There is no zero-configuration path that turns an arbitrary bot into a listing, and uploading a template is not the same as selling remote execution.

In the Seller Console, Models and APIs are separate starting points from Resources. Under Resources, the type list in the 17 November 2026 recording includes Skill, Bot, Service, Data, and Goods. You do not have to add every type. Available listing and delivery options depend on the resource.

The public seller docs work through one illustrative listing for each of those paths. Use them as packaging patterns, not as live catalog items.

Type Official illustrative example Buyer inputs Buyer receives A limit the listing should state
Skill Competitor research skill Industry, target region, competitor names, and the question to answer A competitor comparison, source links, a brief, and explicit gaps in the evidence Source coverage and the update date. Do not promise complete, real-time, or legally cleared research.
Bot Brand planning bot Product, audience, brand tone, and the campaign goal Positioning directions, message options, and a structured creative brief Included scope. This example does not include a finished logo, website build, or trademark clearance, and it should not imply unlimited revisions.
API Company lookup API Company domain and requested fields Company profile, data timestamp, source, and missing-field indicators Do not sell private personal data or data you lack permission to distribute. You remain responsible for lawful access and the published contract.
Service Receipt extraction service A permitted receipt image and the requested fields Structured merchant, date, currency, and total, with confidence or validation notes Extraction is not accounting certification. State retention, privacy, and deletion practices. Only advertise tasks your endpoint can execute.
Data Industry price dataset Product category, region, and observation period Matching records, collection date, units, source notes, and coverage gaps No guaranteed completeness, investment advice, or automatic right to resell the dataset. Do not present a static sample as a continuously updated feed.

Two further official illustrations sit next to those five. Models use the existing Models workflow: the docs’ example is a text generation model route, which is inference access, not a sale of model weights or a promise of ownership. Digital goods use the example of a licensed design asset pack: the buyer receives a protected link, expiry, file manifest, and license terms. The docs are explicit that this is a delivery pattern, not proof of a built-in digital-goods entitlement system, and that you should confirm backend support before offering one-time ownership. Do not treat every repeated download as a new purchase.

The rest of this article uses the Competitor research skill as the running example, because a callable skill shows the same decisions you will make for a bot, an API, a service, or a dataset: what the buyer sends, what you return, when you charge, and what an empty or late result means.

Package one result an agent can request again

Write the listing as a result, with limits. “Research the competitors for this product, and return a structured brief with sources and gaps” is something an agent can evaluate. “We do AI research” is not.

Listing field Competitor research skill (illustrative)
Buyer inputs Industry, target region, competitor names, and the question to answer
Your execution Your agent runs the skill, queries permitted sources, and assembles the findings
Buyer receives A competitor comparison, source links, a brief, and explicit gaps in the evidence
Billing example USD 0.50 per qualifying call, for illustration only. At 20 qualifying calls, gross charges are USD 10 before your execution costs and applicable fees. That is not an earnings forecast.
Repeat use A later request for a different region, a product launch, or a weekly update
Scope limits State the source coverage and the update date. Do not promise complete, real-time, or legally cleared research.

The same fields apply if you later list one of the other official patterns. A company lookup API still needs requested fields, a timestamp, and a documented no-match. A receipt extraction service still needs the output schema and what “uncertain” means. An industry price dataset still needs freshness, units, and the cost of an empty query. A brand planning bot still needs the included scope, so a second campaign is a new task rather than an unbounded revision of the first.

A callable skill is also different from a downloadable skill package. The console configures the service endpoint. It does not install, host, or execute your private skill for you.

The official fields still need a contract a buyer can inspect. The JSON below is illustrative: a sample for this article’s competitor research skill, not an OpenAny API contract, a required field list, or a live route. The seller docs read on 18 November 2026 do not publish one fixed schema that every listing must use. These samples contain no credentials.

An example request a buyer’s agent might send after a person authorizes a budget:

{
  "industry": "developer tools",
  "target_region": "Southeast Asia",
  "competitor_names": ["ExampleCo", "Sample Labs"],
  "question": "How do these companies describe their agent integrations in public, and where is the evidence thin?"
}

An example result inside the published scope, with source, freshness, and coverage the buyer can check:

{
  "brief": "ExampleCo publishes an agent-integration page; Sample Labs does not.",
  "comparison": [
    {
      "name": "ExampleCo",
      "finding": "Public docs describe an official agent integration.",
      "source_urls": ["https://example.com/docs/agents"]
    },
    {
      "name": "Sample Labs",
      "finding": "No comparable public integration page was found.",
      "source_urls": []
    }
  ],
  "evidence_gaps": ["No public pricing page for Sample Labs was found as of the coverage date."],
  "coverage": {
    "as_of": "2026-11-18",
    "sources": "Official product pages and docs cited in source_urls",
    "limits": "English-language public web only; not complete, real-time, or legally cleared."
  }
}

An example business error when the request is outside published coverage — a defined outcome, not a disguised crash. Say whether you return this in the body, and which charge rule applies, before the buyer authorizes the call:

{
  "ok": false,
  "error": {
    "code": "OUT_OF_SCOPE",
    "message": "The requested region is outside the published coverage. No research was run."
  },
  "coverage": {
    "as_of": "2026-11-18",
    "limits": "Published coverage is Southeast Asia, English-language public web sources only."
  }
}

The field names above (brief, coverage, ok, error.code) are part of this illustration, not an official OpenAny schema. A fixed price per call on a defined brief does not need a usage quantity. Usage-based billing, the seller docs say, needs a trustworthy quantity plus the JSON Pointer, unit, and rounding you configure. The 17 November 2026 console helper showed that quantity as usage.count, for example {"usage":{"count":100}} (100 × price when unit quantity is 1). Use it only when your charge rule points at that field.

How a call travels from the buyer’s agent to your service

Before you fill in the form, it helps to see who does what. Your runtime stays with you. The buyer’s agent is not hosted by OpenAny.

Conceptual five-step flow: a human authorizes a budget, the buyer’s agent calls, OpenAny routes and meters, the seller-owned runtime executes, and the result and usage record come back.
Conceptual flow, not a product screenshot. The buyer’s agent and your service both run outside OpenAny. Charges follow the listing’s billing unit and charge conditions; payment does not have to be a separate step before every call.

The public seller overview says the same thing in four strokes: the buyer agent submits inputs, OpenAny routes the call, your endpoint executes, and the buyer receives the result. A person still has to authorize the spend. Sign-in is not permission to pay. A buyer may already have a prepaid balance. Direct x402 is a separate path, and only where an endpoint explicitly supports it.

For the competitor research example, that means the industry, region, competitor list, and question travel to an endpoint you operate. OpenAny records the call against the billing rule you published. The brief comes back from your environment, not from a runtime OpenAny hosts for you. The same path holds for a lookup API or a receipt service: you keep execution, and the listing has to describe the result the buyer is paying for.

Connect a callable interface

For a skill, the docs ask you to run it in your own agent or server, provide an endpoint you control, and confirm you may use its tools and data commercially. In the console you bind an API Key connection — those are seller connection credentials, not a buyer OpenAny API key — and set the HTTP method, call path, required inputs, and example responses. Choose synchronous or asynchronous execution to match how your endpoint actually works.

The Request step is where that choice appears. The following screens are from the same 17 November 2026 recording, placed here because this is the step they document: one configuration returns the result immediately, the other returns a task ID so the result can be retrieved later.

Two Seller Console Request screens from a 17 November 2026 recording: synchronous execution returns results immediately; asynchronous execution returns a task ID to retrieve results later. Example path values only.
Seller Console, 17 November 2026 recording. Example path values, not a published listing. Burned-in video captions were cropped out; no form values were edited.

Synchronous delivery returns the result in the call response. Use it when the work fits the endpoint timeout — a short transformation, a single company lookup, or a tight competitor brief you can finish in time.

Asynchronous delivery accepts a task and supplies the final result through the configured callback or polling contract. For competitor research that needs more time, or for a larger receipt batch, this is usually the better fit. Configure the timeout, how the result is retrieved, how long it remains available, and when the call is billed. Accepting a request or returning a task ID is not completed delivery. For delivery-based billing, acceptance alone is not a basis to claim completed-delivery earnings.

For asynchronous work, Seller Terms require you to follow the supported task and result-delivery protocol, including the supplied callback URL where applicable, and to state completion criteria, timeout, retrieval method, and result expiration in the listing. A webhook returning 2xx, the docs note, only proves what that response says, so verify both acceptance and final delivery before you publish. Use synchronous delivery only when a typical competitor brief fits the endpoint timeout.

The call path, public-path preview, and service path shown in the recording are example values from that session. They are not a live route to copy, and they are not a curl recipe. Keep credentials out of the public listing, copied instructions, and screenshots.

Set prices and decide when failed or empty calls are billed

The console offers two pricing modes. Pick the one that matches the unit you can actually measure.

Fixed price per call charges the configured amount when the call meets the charge condition. That fits a defined competitor brief, a single company lookup, or one receipt with a clear “one job” boundary.

Usage-based billing reads a declared quantity in the response and applies the unit, quantity, scale, and rounding you configure. The helper text in the recording tells you to include the billable quantity in usage.count in your JSON response. In its in-console example, {"usage":{"count":100}} with a unit quantity of 1 means 100 × price. That pattern fits an industry price dataset billed per returned record, or a receipt service billed per processed page, when the returned quantity supports it. Set the condition and the unit to match what you actually return; do not treat that helper’s dollar example as your listing price.

The Pricing step is where those two modes appear. The following screens are from the same recording and belong in this section: fixed price per call on top, usage-based billing underneath.

Seller Console Pricing step from a 17 November 2026 recording, showing Fixed price per call with Charge when HTTP status is 200–299, and Usage-based billing with billing unit, unit quantity, and the usage.count helper.
Seller Console, 17 November 2026 recording. Price fields were empty in the recording; they were left empty here. The usage panel’s “Charge when” row was cropped because a video caption overlapped it; the same HTTP 200–299 condition was visible on that mode in the recording.

The charge condition is configurable. In this recording, the visible default is “HTTP status is 200–299”. That is a technical trigger, not proof that you delivered the agreed brief. Seller Terms require a valid delivery to meet the format, content, scope, and access requirements in your listing. An HTTP success status, or a met technical charge condition, is not enough on its own. Do not treat a blocked request, a rate-limit page, an error body, or fabricated data as a successful delivery.

A genuine empty result or no-match can be a valid result if the listing explains that possibility, and its charge rule, before the buyer authorizes the call. Say what an empty competitor brief, a company lookup with no record, or an unmatched price query costs. Do not disguise an execution failure as an empty result. A timeout alone does not prove that no billable usage occurred. Before you retry an uncertain paid request, inspect the original task and the usage record. A duplicate notification or callback for the same task is not a new purchase.

Testing can incur costs. The docs ask you to save a draft and authorize a bounded test; verification may be billed. In the same recording, saving a record is not the same as passing the test. Review the receipt before you publish. Local mock calls, the docs note, are not billed.

A useful price starts with a sharp task boundary. For the competitor research skill, decide what one qualifying call includes — one industry, one region, a stated number of competitors, and one question, for example. A later region or weekly update is a new call; a legal opinion or a live-monitored feed is out of scope. Keep fixed price per call for that defined job; use usage-based billing only when you can measure a returned quantity, such as records or pages, at the JSON Pointer you configured.

Count execution cost before you publish a rate. The official illustration remains USD 0.50 per qualifying call, or USD 10 gross at 20 calls, before execution costs and applicable fees — not a required price or an earnings forecast. The seller docs ask you to deduct model, tool, server, support, and applicable payment or payout costs when judging your margin. Seller Terms deduct a 2.5% service fee from the seller payout, not the buyer price, and illustrate it on a USD 100.00 payout before fees: USD 2.50, leaving USD 97.50 before any separately itemized third-party transfer charges or required tax withholding. The same 2.5% on a USD 10 confirmed payout would be USD 0.25, still before your own execution costs. If the residual cannot cover a typical call, raise the rate or narrow the job. Do not add unapproved operating costs to an already authorized transaction, or change its price after the fact.

Check the listing before you publish

The public docs give a five-step path in the Seller Console. Treat it as a pre-publish check, not as a ceremony after the fact.

  1. Admission is complete. Create your seller profile and finish supplier admission. Review is required once. A saved draft is not admission, and it is not publication.
  2. The contract is specific. You control the service, the connection is authorized, and the input/output contract is precise enough that a buyer’s agent can evaluate it. OpenAny does not host your runtime.
  3. Prices and charge rules are explicit. Fixed or usage-based billing is set, including what happens on an empty result, a no-match, a timeout, or a failed execution. Credentials are not in the public listing.
  4. A bounded test has been authorized and reviewed. Save the draft, run the test, and read the receipt. Saving is not passing. Publication and runtime readiness are separate states.
  5. The buyer-facing preview matches the result you can deliver. For a skill, the docs also ask you to complete the name, categories, description, Overview, Included, How to use, and Examples, and to describe a result rather than an unsupported promise. An agent can prepare a draft. You review the details and authorize verification and publishing yourself. Testing and publication each need their own authorization.

Those buyer-facing fields are also how a person or an agent evaluates the listing. Search indexing, AI citation, and an agent purchase are different steps; publishing on a B2A marketplace does not guarantee any of them. The seller docs describe these fields and the Market as where people and agents can discover a public listing. They do not say that OpenAny automatically applies SEO to every listing, or that a listing may use an arbitrary schema.

Make the public listing evaluable — writing advice for the listing, not a ranking promise:

  • Use a task-shaped name that states the result — a competitor-research brief with sources and gaps — not a slogan.
  • Keep a stable public description, and update it when the contract changes.
  • State verifiable sources and dates, plus inputs, outputs, price, and billing unit, including the charge rule for an empty or out-of-scope result.
  • Include examples and limits that match the endpoint, and say what is included, how long delivery takes, when the call is billed, and what happens when evidence is thin.
  • If you keep a public documentation page you control, keep it consistent with the listing and reachable without a special login. That is a clarity habit, not a claim that Market pages are indexed.

Listing is free, and you set your own prices. As of the public seller pages and Seller Terms read on 18 November 2026, OpenAny adds no markup to your published rate and does not take a sales commission from individual purchases or calls. Payment, network, or payout fees may still apply. Payouts are processed monthly. The minimum payout is USD 20.00 before fees; smaller confirmed balances carry over. A 2.5% service fee is deducted from the seller payout, not added to the buyer price. Estimated earnings in Seller Revenue are not a withdrawable balance; confirmed settlements appear in Payouts. Buyers inspect usage records and available results in Usage. Direct x402 payments require explicit endpoint support and are separate from balance funding.

A successful test or review is not an endorsement, and OpenAny does not guarantee traffic, sales, or earnings.

After you publish, how a buyer’s agent uses the listing

Once the listing is public, people and AI agents can discover it in the Market, read the published price, access requirements, and delivery terms, and pay to use it. The person behind the agent should review that price and authorize a task budget first.

In the competitor research example, that might look like this. A developer authorizes a budget. Their agent sends an industry, a region, a list of competitors, and a question. Your endpoint — running in your environment — returns a comparison, source links, a brief, and the gaps you are willing to state. The buyer inspects the result and the usage line: what was called, what was charged, and under which authorization. If the charge condition was not met, or the result was an explained no-match, the billing follows the rule you published.

The same sequence applies to the other official patterns. A bookkeeping agent can send a new receipt each time one arrives. A lead-enrichment agent can call a company lookup when a new domain appears. A market-monitoring agent can request the next period of an industry price dataset. In each case, the buyer is paying for the result and the charge rule you published, not for informal “it basically worked” effort.

Once a few real calls can be authorized, verify a small, bounded sample yourself: one in-scope brief, one out-of-scope or no-match case, and, if you offer async delivery, one task followed through to the final result. Inspect Seller Revenue for estimates and Payouts for confirmed settlements. Buyers inspect usage records and results in Usage. Those views record calls, estimates, and settlements; they are not a full operations log of your runtime.

Keeping your own execution logs is general advice, not a described OpenAny dashboard. Log enough to see whether you delivered the published result, whether a retry would duplicate a charge, and when you changed the contract. Do not store credentials, or more buyer content than the task and the law require. Seller Terms say OpenAny does not persist API request or response contents as stored content; it processes that content in transit to return the result. Account, payment, and usage records are still kept, and asynchronous results may have their own storage and expiration rules. Your service is not promised zero retention, so explain your retention and third-party policies in the listing.

Keep upstream credentials and your Seller key private. The Seller key authenticates supported seller callbacks; it is not a buyer API key or permission to spend a buyer balance. Use buyer inputs only to fulfill the authorized task; do not sell, market with, train on, or share them for unrelated purposes without a separate lawful basis and any required authorization. If you discover unauthorized access to or disclosure of buyer information connected with your OpenAny service, notify team@openany.si without undue delay, without sending secrets.

Rate limits on your own endpoint are your responsibility as an operator — that is general advice. The terms already require that a blocked request, a rate-limit page, an error page, or fabricated data must not be presented as successful delivery. If you cannot fulfill new work, stop accepting it; stopping new sales does not cancel obligations already accepted. When you change the skill, update the public listing before you accept new work. Already authorized transactions keep the agreed price and conditions.

For the wider buyer-side picture of how agents discover, choose, and pay for services, see The B2A Economy: How AI Agents Discover, Choose, and Pay for Services on this blog.

If you want to prepare a first listing, start with one outcome on the seller pages and the seller overview in the docs. Copying a setup instruction does not submit an application, run a paid test, or publish anything. Those steps still need your approval.

FAQ

What is a B2A marketplace?

A B2A marketplace is a market where businesses sell skills, bots, APIs, data, and services to AI agents that act for a person or an organization. The agent can discover a listing, call it, and pay for a completed use after a person authorizes the spend. In this article, B2A means Business-to-Agent, not Business-to-Administration.

What can I sell on a B2A marketplace?

On OpenAny, you can list a callable skill, bot, API, service, or dataset, and, where the current workflow supports them, a model route or a digital-goods delivery. The official docs illustrate those paths with a competitor research skill, a brand planning bot, a company lookup API, a receipt extraction service, an industry price dataset, a text generation model route, and a licensed design asset pack. Start with one outcome you can actually deliver. A Hermes agent, a Grok Bot, or any other bot belongs here only if you can expose a trigger and return a result.

Is a downloadable template the same as a callable service?

No. A template gives the buyer files or a package to run in their own environment. A callable service is work you run, through an endpoint you control, that returns an agreed result. OpenAny connects the two sides. It does not turn a template upload into remote execution.

Does OpenAny host my bot, skill, or API?

No. Your runtime stays in an environment you control. OpenAny routes and meters the call and does not host or operate your bot, skill, or external service. You remain responsible for availability, permissions, capacity, and delivery.

How should I price a skill or API: fixed price per call or usage-based billing?

Use fixed price per call when one qualifying task is one job, such as a defined competitor brief or a single company lookup. Use usage-based billing when you return a measured quantity, such as records or pages, and can include that quantity in usage.count. In either case, publish the charge condition, including what an empty or no-match result costs. Set a rate that can cover your execution costs and applicable fees.

If a call returns HTTP 200, has the work been delivered?

Not by itself. HTTP 200–299 is a configurable technical condition in the Seller Console recording; it is not the same as meeting the format, content, scope, and access requirements in your listing. A blocked request, an error page, or invented data is not a successful delivery. A genuine empty result can be valid only when the listing has already said so.

When is an asynchronous job complete, and when is it billed?

The job is complete when the final result is supplied through the callback or polling contract you configured, not when the endpoint accepts the task or returns a task ID. Configure timeout, retrieval, retention, and the charge rule up front. Acceptance alone is not a basis to claim completed-delivery earnings. A duplicate callback for the same task is not a new purchase.

What should I check before I publish a listing?

Confirm supplier admission, a precise input/output contract, explicit prices and failure rules, a reviewed bounded test, and a buyer-facing preview that describes a result you can deliver. A saved draft is not admission or publication. Testing and publishing each need their own authorization.

Is the sample JSON an OpenAny API contract?

No. It illustrates a competitor-research result you might document in your listing, not a required OpenAny field list or a live route. If you use usage-based billing, follow the quantity field and JSON Pointer you configured. The console helper used usage.count.

Will publishing a listing get it ranked in search or cited by AI systems?

Not automatically. Search indexing, AI citation, and an agent purchase are different steps. The public seller docs do not claim that OpenAny runs SEO for every listing.