OpenAny

How to Sell Your API to AI Agents: Pay-Per-Call Pricing, Agent-Readable Listings and Honest Trade-offs

OpenAny — Tue, 03 Nov 2026 06:23:48 GMT

Disclosure: this post is written by the OpenAny team, and OpenAny is our product. Most of it applies to any pay-per-call channel. The trade-offs section is there on purpose.

A new kind of customer is calling your API

The usual way to sell an API assumes a human buyer. Someone finds your landing page, signs up, reads the docs, picks a monthly tier, puts a card on file and, if the account is big enough, talks to sales.

A coding agent running in Claude Code, Cursor or Codex skips almost all of that. Partway through a task it decides it needs, say, company data for a domain. Then it:

discovers candidate APIs by searching a catalog,
inspects one listing to read its input schema and its price,
calls it, often with a per-request cost cap set by the developer, and
pays for that one call out of a balance someone already funded.

Nobody signs up for your service, nobody picks a plan and nobody talks to sales. The decision takes seconds and is based almost entirely on what your listing says. If the schema is vague or the price is unclear, the agent picks another listing or gives up.

That changes what "selling an API" means. You're no longer selling a subscription to a person. You're selling individual calls to software that reads your contract literally.

What an agent needs from your API listing

When we review listings from the agent's side, the same few things decide whether a call happens and succeeds.

1. A complete, strict input schema. Agents build requests from the schema, not from prose examples. Every parameter needs a name, a location (query, path, body), a type, whether it's required, and a one-line description. Ambiguity turns into malformed calls, and malformed calls turn into retries.

2. A fixed, visible price per call. An agent, or the developer approving its budget, has to know the cost before the call. "Starts at" pricing or "contact us" pricing doesn't work here. A flat per-call price is easiest to reason about. Usage-based units are fine if the unit is explicit.

3. A clear rule for what gets charged. Agents retry. If a 500 or a validation error costs money, a confused agent can burn a buyer's budget quickly. Decide up front which responses are billable (for example, only HTTP 200) and say so.

4. Small, predictable responses. Every byte you return ends up in an agent's context window. A 40 KB payload where 2 KB would do is a worse product for an agent, even if it's a better product for a dashboard.

5. Predictable errors. Use consistent status codes and machine-readable error bodies. An agent that can tell "bad input" from "rate limited, retry after N seconds" from "upstream down" behaves far better than one that only sees "something went wrong".

6. One job per endpoint. "Look up a company by domain" is easy for an agent to match to a task. "Universal enrichment endpoint with 30 optional flags" is not.

None of this is OpenAny-specific. If your API already does all six, you're ahead of most listings an agent will see.

Pricing your endpoint per call

Per-call pricing feels unfamiliar if you've only sold tiers, so here's a practical way to set it.

Start from your cost per request. Include upstream data costs, compute and a share of infrastructure. Then add your margin. That gives you a floor.
Price the unit the buyer actually understands. For most data and tool endpoints that's "one successful call". Use a usage unit (records returned, pages scraped, seconds of media) only when cost genuinely scales with it.
Price successful calls only. It's easier to sell and agents behave better against it. Pair it with input validation so bad requests fail fast and cheaply on your side.
Look at comparable listings. Agents can compare prices for similar capabilities directly. You don't have to be the cheapest, but your listing should make it obvious what the extra cost buys (fresher data, better coverage, smaller responses).
Keep it boring. One price per endpoint beats clever discounts that an agent can't evaluate in one read.

On OpenAny specifically, prices are set in USD, and per-call amounts are stored in micro-USD (one millionth of a dollar), so sub-cent prices are fine. A price like $0.002 per call is expressed as "2000" micro-USD. Amounts that would need rounding below one micro-USD are rejected rather than silently rounded.

How listing on OpenAny works, step by step

OpenAny is a pay-per-call marketplace for AI agents: models, data APIs and agent skills under one API key and one prepaid balance on the buyer side. As of 2026-11-03 the published catalog lists 3,138 API endpoints and 154 models from 59 provider identities. Those are listing counts, not traffic numbers. (If you want the buyer's view, we covered developer setup in a separate post on DEV.)

For providers, the provider page states the commercial basics: listing is free, you set your own prices, and there's 0% markup on your published rate. Payment, network or payout fees may still apply.

The flow looks like this:

1. Create a provider profile. Sign in to the Provider Console with an email account and create a supplier profile. Supplier admission is reviewed by a human once. After that, individual APIs don't need a separate resource review.

2. Add an upstream connection. This is the base URL of your API plus how OpenAny authenticates to it. For automatic publication, the supported options are no auth, a static bearer token, or an API key in an api-key, x-api-key or x-treg-token header. The upstream key is stored encrypted and is never returned by the API. OAuth2 flows and custom secret headers need extra connection work before they can go live.

3. Describe each endpoint. For each endpoint you declare the method, path, every accepted input and how it maps to your upstream, a timeout, request and response size limits, the price and billing unit, and a charge condition (for example, charge only when the upstream returns HTTP 200). Undeclared parameters are rejected rather than forwarded, so the contract the agent sees is the contract your server gets. Usage-based billing reads the quantity from a JSON Pointer in your response that you specify.

If you already have an OpenAPI 3.x JSON spec, you can import it. Each operation becomes a separate draft, up to 100 items per batch. Import doesn't infer prices or charge rules, so you still fill those in yourself.

4. Verify, then publish. You run a verification call against the saved configuration, using test input and a cost limit you choose. Only a passed verification can be published. Activation and runtime availability are reported as separate states, so "published" and "live and routing traffic" aren't confused.

You can do all of this in the console or hand it to your own agent. There's a provider onboarding skill that walks an agent through drafts, verification and publication with the openany provider CLI commands. It's written so the agent never asks for your upstream key in chat: you enter it locally through stdin.

5. Get paid. Revenue accumulates in your provider balance in USD, and payouts are processed once per month in USDC, net of applicable taxes. The Provider Console shows your usage, revenue and payouts.

On the buyer side, nothing extra is required from you. Developers fund one OpenAny balance by card, USDC or x402 top-up and authenticate calls with their OpenAny key. Your endpoint doesn't need to implement x402 to be listed. (Direct per-request x402 payment is a separate flow that only applies to endpoints that explicitly support it.)

Honest trade-offs: when a marketplace isn't the right call

A marketplace is a distribution channel, not a replacement for your own business. Some reasons to think twice:

Fees still exist. "Free to list" and "0% markup" don't mean zero cost. Payment, network or payout fees may apply, so read the terms and do the math on your margin before you set prices.
You lose some of the customer relationship. The agent's developer pays OpenAny, not you. You see usage and revenue, but buyer identities aren't shared with providers, so you won't get a signup, an email address or a sales conversation from each buyer. If your business depends on upselling accounts, that matters.
Changes need re-verification. You can update or unpublish an endpoint whenever you need to, but changing an endpoint's configuration or rotating its credential means verifying it again before the new version goes live. Plan schema changes rather than shipping them casually.
Not every auth model fits yet. If your API requires per-user OAuth, it isn't a good fit for automatic publication today.
Per-call pricing can undercut your tiers. If your direct customers pay $99 a month for a volume that costs much less per call on a marketplace, some will notice. Price consistently across channels.
It's a young marketplace. Listing counts aren't demand guarantees, so treat it as an additional channel and measure it.
Stay direct when you sell large enterprise contracts, need deep account-level integration, or your API is stateful and multi-step in a way that doesn't map to single calls.

It's a good fit when your API is already self-serve, does one clear thing per endpoint, has a cost per call you can state, and you want agents to be able to find and use it without a signup step.

Wrapping up

Agents are a strange new customer: they never read your landing page, they don't negotiate and they leave the moment your contract is unclear. The work of selling to them is mostly the work of making your API legible: strict schemas, one fixed price, a clear charge rule, small responses and honest errors.

If you want to try that with OpenAny, the provider page has the console and the onboarding skill. Questions, or a listing that didn't fit our schema? Email us at team@openany.si.

Connect Claude Code to 3,000+ APIs With One Sentence (Step-by-Step Guide)

OpenAny — Thu, 29 Oct 2026 14:17:08 GMT

In the first post we covered why your agent hits a wall the moment it needs real data. This one is hands-on: connecting Claude Code to OpenAny, making a first real call, and checking what it cost.

Your part: one sentence, plus one setup command in your own terminal.

What you need

Claude Code with terminal access.
Node.js 22+, which the OpenAny CLI requires (node --version).
A wallet or an email address for your OpenAny account. If you already have an OpenAny API key, you can use that instead.
A small balance. All calls draw from one shared balance.

Step 1: Give Claude Code the sentence

Open Claude Code in any project and type:

Read openany.si/AGENT.md and connect OpenAny

That's the whole integration prompt. AGENT.md is written for agents. It tells Claude Code what to install, where the skill goes, and what it must never do with your credentials.

Illustration (not a real session) of the steps AGENT.md tells Claude Code to take.

Step 2: What Claude Code does next

Following the published Claude Code recipe, your agent:

Installs the OpenAny skill at .claude/skills/openany/SKILL.md, so future sessions know how to use it.
Installs the CLI:

npm install -g openany-cli@latest --registry=https://registry.npmjs.org/
openany --version
openany --help

Checks your configuration with openany status --scenario call -j, reading the configured and missing fields. A passing local check only means the settings exist. It doesn't prove the key works yet.

Claude Code keeps its own main model. OpenAny doesn't replace it. It adds models, data, and tools the agent can call.

Step 3: Sign in without pasting secrets into chat

This is my favorite part. If you don't have a key yet, Claude Code asks whether you want to use a wallet or email, then hands you a command to run in your own terminal:

# Email: you enter only your email address
openany setup --scenario email

# Wallet: private key at a hidden prompt, plus a stable Agent ID like agent-main
openany setup --scenario wallet

Then you reply "configured" and the agent continues:

Email: a six-digit code is sent (openany auth email send) and verified (openany auth email verify --code ...). Then a key is created.
First-time wallet: the agent creates a key (openany keys create --identity wallet --label agent-main -j), which registers your account and balance. Then it logs in with openany auth wallet -j.

The key is saved locally in ~/.config/openany/credentials.json (file mode 0600). The docs are explicit: never paste API keys, private keys, seed phrases, or codes into any AI chat. The agent is instructed never to ask for them. Already have a key? Run openany setup --scenario call and enter it at the hidden prompt.

Illustration (not a real session) of email setup in your own terminal, with generic values.

Step 4: Fund your balance

Add credits from the OpenAny dashboard at openany.si. See openany.si/pricing for the current options. Your agent can check your balance at any time:

openany balance -j

Nothing tops up automatically by default. Agent-driven top-ups are opt-in, with limits you approve up front: per-payment cap, total cap, network, purpose, and expiry.

Step 5: Make your first real call

Ask for something real, in plain English:

Using OpenAny, find an API that returns the top Instagram posts
for the hashtag #coldbrew. Show me the price before you call it,
keep it under $0.05, and give me the results plus the request ID.

Claude Code follows the same loop every time:

openany balance -j                                          # can we afford it?
openany discover -q "instagram hashtag top posts" -l 10 -j  # find candidates
openany inspect --id API_ID -j                              # schema, version, price
openany run --id API_ID --query '{...}' -j                  # the actual call

API_ID comes from the live catalog, and the parameters come from inspect, so nothing is guessed. If several providers match, the agent should ask you which one to use.

Here's my real run. discover found Instagram Hashtag Top Posts. Before anything was spent, inspect showed the price and the one required field:

{
  "name": "Instagram Hashtag Top Posts",
  "method": "POST",
  "revision": 2,
  "price_usd": 0.0011,
  "required": ["hashtag"]
}

That's about a tenth of a cent. I capped the call with max_cost_usd, so no route could charge more than one cent, and asked for three rows:

openany run --id 9cc6f928-f102-415e-aeec-db2fc21aaeb5 \
  --query '{"max_items":3,"max_cost_usd":"0.01"}' \
  -i '{"hashtag":"coldbrew"}' -j

Response (trimmed):

{
  "status": 200,
  "requestId": "64fbd8a3-75c5-4692-99ca-0b19d6ddb2f7",
  "provider": "AnyAPI",
  "costUsd": 0.0011,
  "shown": { "shown": 3, "total": 24 },
  "posts": [
    { "caption": "Jangan sampe niatnya milih satu, malah k", "likes": 1148, "comments": 20, "views": 22174 },
    { "caption": "we, the people who don’t put sugar or sw", "likes": 503388, "comments": 3605, "views": 6663369 },
    { "caption": "Nah ini coldbrew pake espresso blend, be", "likes": 48, "comments": 7, "views": 1196 }
  ]
}

That's live Instagram data, and I never opened an account with a scraping service.

Real output from our test run, trimmed with jq.

Tip: the CLI validates parameters before sending. My first try passed "max_items":"3" as a string. The CLI rejected it locally (Invalid type for max_items), so nothing was sent and nothing was charged.

The same CLI covers models too: openany models list, openany models prices, and openany models run with the operation that the model's listing publishes.

Step 6: Check what it cost

The response already includes costUsd: 0.0011 next to a requestId. To double-check, I compared the balance before and after:

{ "charged_usd": 0.0011 }

The quoted price matched the charged price. There was no hidden fee and no monthly minimum.

Real output from our test run: the response's cost and the balance difference.

Illustration summarizing the flow, using the real numbers from the run above.

For data and tool APIs, openany calls list and openany calls get --id REQUEST_ID show your call history. Model calls and overall usage also appear in the usage records in the dashboard.

Troubleshooting

configured: false: run setup on the same machine and account where Claude Code runs.
401: check your API key. The agent shouldn't keep retrying with a bad one.
Email session expired: openany auth email refresh -j.
402 / insufficient balance: add credits in the dashboard.
Timeout: don't repeat a paid request blindly. Check openany calls list first.
OPENANY_API_KEY is set in your shell: it overrides the key the CLI saved.
Just browsing? openany discover -q "..." --public and openany models prices --public work without a key.

Next steps

You've connected Claude Code, made a call, and seen the receipt. Now try something bigger. The first post has two full workflows (market research and a competitor price tracker) you can paste straight in.

Using Cursor, Codex, OpenClaw, or Hermes Agent? It's the same sentence. Each client installs the skill in its own folder (see the client recipes).

👉 openany.si · Docs · X: @openanysi

Keep your agent. Connect it to more.

Your AI Agent Is Smart. It Just Can't Reach Anything. Meet OpenAny.

OpenAny — Wed, 28 Oct 2026 03:22:17 GMT

You ask your agent to do something real, like research a market or monitor competitors, and it stops cold.

"I need an API key for that."

So you sign up for a search API. Then a product data API. Then a social data provider. Then an LLM. Five accounts, five keys, five invoices, and you haven't shipped anything yet.

OpenAny fixes that. It's the open marketplace for AI agents: 161 AI models and 3,000+ API endpoints, all reachable through one connection, one key, and one balance.

You don't replace your agent. You connect the one you already use (Claude Code, Cursor, Codex, Gemini CLI, Hermes Agent, or OpenClaw) with a single line:

Read openany.si/AGENT.md and connect OpenAny

From then on, you ask for the outcome, and your agent finds and pays for what it needs.

Here's what that looks like in practice.

Use case 1: Sarah validates a product idea before lunch

Sarah runs a small e-commerce brand. She's thinking about launching a portable coffee maker, but before she spends money on samples, she wants to know: is there room in this market?

Normally that means a week of work: browsing Amazon listings, reading hundreds of reviews, scrolling TikTok for trends, then writing it all up.

Instead, she opens Claude Code and types:

Research the portable coffee maker market.
Find the main competitors and their price range,
summarize what Amazon reviewers complain about,
check what's trending on TikTok,
and tell me where the opportunity is.

Her agent goes to work through OpenAny:

Search finds competitors and market sources
Amazon data pulls product listings, prices, and reviews
TikTok data surfaces trending videos about travel coffee
An LLM synthesizes everything into one brief

A few minutes later, she has her answer: the price range competitors sit in, the top complaint in reviews (cleanup is a pain), and a content angle that's already working on TikTok (show the brew, then the cleanup).

Her positioning: portable coffee with easy cleanup.

She never created an Amazon data account, a TikTok API account, or an LLM account. Her receipt shows every call itemized, paid from one balance.

Use case 2: Leo builds a competitor price tracker in an afternoon

Leo is a solo developer who sells a SaaS tool. His three biggest competitors keep changing their pricing pages, and he only finds out when a customer mentions it.

He wants an agent that checks their pricing every morning and tells him what changed. The hard part has never been the logic. It's the plumbing: scraping, parsing, storing, and summarizing, each with its own service.

He asks his agent:

Every morning, check the pricing pages of these 3 competitors.
Extract their plans and prices,
compare them with yesterday,
and send me a short summary of anything that changed.

Through OpenAny, his agent:

Uses TinyFish to extract structured data from each pricing page
Compares today's plans against yesterday's
Uses an LLM to write a two-line summary, like: "Competitor B raised its Pro plan and added an annual discount."

Leo's agent now does in seconds what used to take him an hour of manual checking, and he didn't sign up for a single new scraping service. When a competitor moves, he knows the same morning.

Why it works

Without OpenAny	With OpenAny
A separate account for every provider	One connection
A pile of API keys	One key
Multiple invoices and top-ups	One shared balance
You pick every endpoint	Your agent picks what it needs

There are no subscriptions. You pay for measured usage, with an itemized receipt for every task, and you can top up by card through Stripe or with USDC via x402.

Try it in 30 seconds

Paste this into your agent:

Read openany.si/AGENT.md and connect OpenAny

Then ask it for something you've been putting off.

👉 openany.si · Follow us on X: @openanysi

Keep your agent. Connect it to more.

Sarah and Leo are illustrative examples. Screenshots are demo examples from openany.si and do not show real requests or charges.