One API Key, One Balance: Wiring Models and Data APIs into Claude Code, Cursor and Codex

Disclosure: this post is written by the OpenAny team. OpenAny is our product. We tried to keep it practical, and the limitations section is there on purpose.

The problem: every new tool is another key and another bill

A coding agent rarely stops at one model. In a typical week ours used a frontier model for planning, a cheap fast model for bulk edits, a search API to read the docs, and something to pull GitHub repository metadata. Every one of those meant:

• a new account and a new API key in .env,
• another prepaid balance or card on file,
• another usage dashboard to check when a bill looked wrong,
• another set of rate limits and error formats for the agent to learn.

Agents make this worse because they decide to call things on their own. "Which key paid for that call, and how much did it cost?" gets hard to answer quickly.

We built OpenAny for that case. It's a pay-per-call marketplace where models, data APIs and agent skills sit behind one API key and one prepaid balance. This post shows the actual setup in Claude Code, Cursor and Codex, the commands involved, and where it isn't a good fit.

What you get (and what you don't)

• Models through an OpenAI-compatible Chat Completions endpoint at https://api.openany.si/v1.
• Data and tool APIs (search, GitHub, finance, e-commerce, SEO and more), called through the openany CLI. Each listing shows a fixed price and a billing unit.
• Skills: portable SKILL.md workflows. They run inside your agent and call the models and APIs above. OpenAny doesn't host a skill runtime.
• Billing: one shared prepaid balance with no subscription. You can top up by card, USDC or x402, and card auto top-up and USDC subscriptions are both available. New accounts get $1 in signup credit that doesn't expire.

As of 2026-11-03 the published catalog lists 154 models, 3,138 API endpoints and 59 provider identities. Those are listing counts, not uptime claims.

There's no MCP server. The integration is a CLI, a skill file and plain HTTP endpoints.

Step 1: Get a key and make a first call

Create an account, then create an API key from the dashboard. Put the key in the environment of the process that runs your agent, not in a prompt:

export OPENANY_API_KEY="..." # better: your shell's secret manager or the client's secret store 

Pick a model ID from the model catalog. Model IDs are route-specific, so copy the ID from the listing instead of guessing. The examples below use deepseek-v4-flash, which was listed when we wrote this.

cURL:

curl --fail-with-body --silent --show-error \ https://api.openany.si/v1/chat/completions \ -H "Authorization: Bearer $OPENANY_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "deepseek-v4-flash", "messages": [{"role": "user", "content": "Reply with exactly: OpenAny connected"}], "max_tokens": 32 }' 

Python (official openai package):

import os from openai import OpenAI client = OpenAI( api_key=os.environ["OPENANY_API_KEY"], base_url="https://api.openany.si/v1", ) response = client.chat.completions.create( model=os.environ.get("OPENANY_MODEL", "deepseek-v4-flash"), messages=[{"role": "user", "content": "Reply with exactly: OpenAny connected"}], max_tokens=32, ) print(response.choices[0].message.content) print(response.usage) 

A successful call returns HTTP 2xx with a non-empty choices[0].message.content. The usage block tells you what you were billed for.

Some models have more than one provider route. The catalog listing shows the routes for each model.

Step 2: Install the CLI and the skill

Data APIs and skills go through the openany CLI (Node.js 22 or later):

npm install -g openany-cli@latest --registry=https://registry.npmjs.org/ openany --version openany setup --scenario call # paste the key at the hidden prompt, never in chat openany status --scenario call -j openany balance -j 

setup saves the key to ~/.config/openany/credentials.json with 0600 permissions. If OPENANY_API_KEY is set, it takes precedence over the saved key.

Next, install the OpenAny skill where your agent looks for skills. The file is the same for every client. Only the directory changes:

# Example for Claude Code; swap the directory for Cursor or Codex mkdir -p .claude/skills/openany curl -fsSL https://openany.si/SKILL.md -o .claude/skills/openany/SKILL.md 

Read the file before you install it. It's plain Markdown, and you should know what instructions you're handing to your agent. There's also a shortcut: paste Read openany.si/AGENT.md and connect OpenAny into the agent and let it walk through the same steps.

None of this replaces your agent's main model. Claude Code still uses whatever model you already run. The skill only lets the agent call external models and APIs through the CLI when a task needs them.

Step 3: Call a data API from your agent

Say your agent needs repository metadata such as stars, forks, language and license. Here's what the flow looks like with the CLI. Catalog browsing doesn't need a key:

openany discover -q "github repository" -l 5 --public -j openany inspect --id 2a01d388-02fb-4307-8e47-f3a814d9a3cd --public -j 

inspect returns the method, the input schema and the price. For this endpoint, the input is a required url in the request body, and the billing unit is a fixed price per call ($0.0012 when we checked). Then run it:

openany run --id 2a01d388-02fb-4307-8e47-f3a814d9a3cd \ -i '{"url": "https://github.com/facebook/react"}' \ --query '{"max_cost_usd": "0.01"}' -j 

The response is the repository metadata as JSON, plus the request ID and the amount charged.

That max_cost_usd parameter caps the price for this one request. If no route can serve the call at or below that price, the request is refused before it runs and nothing is charged. The same endpoint accepts fields, max_items and jq query parameters, which shrink the response without changing the cost. That's useful when the agent doesn't need 40 KB of JSON back.

In practice you don't type these commands yourself. You give the agent a bounded task like this:

Use the openany skill. Find an API that returns GitHub repository metadata, show me the price before calling, then fetch facebook/react. Budget: $0.05.

The skill tells the agent to check the balance, discover the API, inspect it, show the cost and ask before spending. After the call it should report the request ID and the charge. To check afterwards, run openany calls list --limit 20 -j or openany calls get --id REQUEST_ID -j.

Step 4 (optional): Use OpenAny as the main model provider

This is separate from tool access. Only do it if you actually want your editor's chat model billed through OpenAny.

Cursor. In Cursor Settings → Models, enter your OpenAny key in the OpenAI API key field. If your version shows Override OpenAI Base URL, set it to https://api.openany.si/v1. Then add an exact model ID from the catalog and send one short test message. Two caveats: Cursor limits own-key access to supported chat models, and Tab completion still uses Cursor's built-in models.

Codex. Merge a custom provider into your user-level ~/.codex/config.toml:

model = "MODEL_ID_FROM_LISTING" model_provider = "openany" [model_providers.openany] name = "OpenAny" base_url = "https://api.openany.si/v1" env_key = "OPENANY_API_KEY" wire_api = "responses" 

Codex uses the Responses API, so the model you choose needs a route that supports Responses, streaming and tool calls. Chat Completions support alone doesn't guarantee that. Restart Codex, send one small request, and check the Usage page.

Check the model listing for Responses support before you switch.

Claude Code. Our documented Claude Code setup is the skill and CLI from Step 2, with Claude Code's own model left unchanged.

Cost control with a prepaid balance

Here's what actually keeps spending bounded:

1. It's prepaid. The worst case is your balance, not an open-ended invoice. There's no subscription, and the $1 signup credit is enough to test the setup.
2. Prices are visible before the call. Every API listing has a fixed price and a billing unit, and inspect returns them, so the agent can show the cost before spending.
3. There's a per-request cap. max_cost_usd on data APIs refuses an over-budget call instead of charging for it.
4. Usage is recorded per call. openany calls list shows a chargedCostMicroUsd for each row, and the dashboard has a usage page.
5. Auto top-up is opt-in. Card auto top-up and USDC subscriptions each need their own authorization. If you let an agent top up through the CLI, you set the network, the per-payment limit, the total limit and an expiry up front.

The pricing page explains billing units and the difference between balance-funded calls and direct x402.

Limitations: when not to use this

• If you only use one provider. If everything you run is on one vendor's API and their billing works for you, an extra layer only adds a hop.
• If you need a hosted MCP server. OpenAny doesn't publish one. The integration is the CLI, SKILL.md and HTTP.
• If your agent can't run a terminal. Data APIs and skills go through the Node CLI. An HTTP-only client can still use the model endpoint, but not the CLI workflow.
• If you need every protocol on every model. Chat Completions works across the catalog, but Responses and Anthropic Messages support depend on the route. Check before switching a main model.
• If you expect x402 everywhere. x402 funds your balance. Paying per request directly with x402 only works on endpoints that explicitly support it.
• If you need a long track record. We launched in October 2026. Listing counts aren't uptime guarantees, so try a few calls before building anything critical on top.

Wrapping up

The practical win is boring, and that's the point. Your agent gets one key, one balance and one usage log, and the main model stays the same unless you choose to change it. Setup is a CLI install, a skill file and an environment variable. If you try it, the docs have the full client recipes. We'd like to hear where it breaks, especially Cursor and Codex edge cases. You can reach us at team@openany.si.

If you run an API and want agents to be able to call it, you can list it on OpenAny for free and set your own prices. Payment and payout fees may still apply.