Per-Call vs Subscription vs Token Pricing for Multimodal Agents (2026): Budget Control on One Bill

A loop that searches notes, writes a brief, and cleans up in a sandbox does not land as one line. It lands as model tokens, a data-API charge, and a runtime bill, often from three vendors. The loop does not notice which meter is the expensive one.

A pay per call AI API charges the unit that succeeded. On SandBase Build there is no subscription under that meter. Models, catalog data APIs, and the sandbox draw one balance, and Activities is where status and cost are supposed to show. Figures below were read from public pages on 2026-11-08. Free allowances have edges. “Sandboxes are free for now” is not a promise that they stay free.

Key takeaway

• Three meters: the live model card (tokens, image, video, or audio), a catalog price per successful data call, and sandbox runtime.
• Build is metered: pay per call, no subscription. Scale is Custom, with no dollar amount on the pricing page.
• Eligible data APIs share 100 free calls per organization per day, reset at 00:00 UTC. Model calls are not those 100. Not every data page shows the free line.
• Catalog search and reading a schema and price are $0. A failed model or API call is $0. Sandboxes are $0 for now; a change is announced first.
• Read the card, cap the loop, run small, then check Activities. Fetch-versus-model architecture, tier tables, and video meters stay on the posts linked below.

The three meters every multimodal agent hits

A language brief, a note search, and a sandbox cleanup are different units even when one key pays for all three.

Pricing groups the audit view as “One activity trail”: model work, real-world APIs, and agent runs that show component and runtime work together. The sandbox is listed on its own as $0 for now, not as a third priced SKU.

Why three invoices become one surprise

A model gateway, a data marketplace, and a separate sandbox each keep a cap. The loop continues when the forgotten cap is the one that matters. One key for models, data, and a sandbox is the one-key stack. How that sandbox compares with other runtimes is the free sandbox note. This page is only the bill. The homepage draws the same three steps — data API, sandbox, language model — and labels that demo illustrative. The meters are not.

Per-call vs subscription vs token

Per-call vs subscription API pricing is the bursty-agent choice. Multimodal work adds a third column, because a token, an image, or a video second can dwarf the HTTP call that started it.

No break-even dollar amount is printed here. ATXP’s 25 April 2026 post argues the same split and shows a sample formula on their site. That sample is theirs. Yours is the monthly floor divided by the catalog price of the call you actually make. If the call count cannot be forecast, stay on the meter and cap it.

When pay-per-call wins

Irregular triggers, tenant volume you do not control, or no baseline yet. ATXP’s useful line is per-call plus a hard cap: the organization balance, a daily bound in your code, or a stop before the next page. An uncapped “it is only a cent” loop is how a catalog price becomes a surprise.

Build, on the pricing page, is the metered plan: “Pay per call. No subscription.” Start is $0 and mentions starter credits. The page does not print a dollar size for those credits, so none is stated here. Scale is Custom, for controls and support, with no public price.

Start / Build Metered (“Pay per call. No subscription.”) / Scale Custom on one balance, with Activities trail below.

When a subscription still wins

Stable volume that clears a break-even you calculated, and a finance team that wants one line. The agent then stops because the pool is empty, not because the task is done. One noisy tenant can eat a shared quota. That commercial shape is the Scale contact path. There is still no Scale price to quote.

When the token meter dominates

The data call was a cent and the brief was not. Tier tables and cache math stay in the LLM API pricing guide. Per-second, per-call, and per-token video meters stay in the video cost model. Re-read the card on the day you run.

OpenAI’s per-run spending controller covers the token slice: count input tokens, reserve the worst case, settle the actual cost, stop before the next request. The cookbook says the budget is model tokens only. Hosted tools and other charges are excluded, and the prices in that article are made up. It does not price a data API or a sandbox.

What is free, and what is metered

Checked on 2026-11-08 against pricing, the homepage, and the sandbox page.

• Up to 35% off selected language, image, and video models. The price on the card is the price you pay.
• Eligible data APIs share a daily free allowance per organization, reset at 00:00 UTC. The homepage states the size: 100 free calls a day. Its FAQ says calls past the allowance bill at the listed price, and that AI model calls are separate.
• Discovery is $0: searching the catalog and reading a schema and price never touch the balance.
• Sandboxes are $0 for now. Fair-use caps may apply. Pricing will be announced before it changes.
• A failed model or API call is not charged. Activities shows status and cost.

The 100 calls are per organization, not per agent. Two loops in one org share the pool. 00:00 UTC is 08:00 the same morning in China (UTC+8).

SandBase pricing — Included on every plan: 100 free eligible data calls/day, $0 Discovery, $0 Sandboxes for now, $0 Failed calls.

Read the card before the run

Claude Sonnet 5.5 (anthropic/claude-sonnet-5.5) that day: $1.70 per 1M input tokens and $8.50 per 1M output tokens, 15% off a list price of $2 / $10. The same card lists cache read at $0.09 and cache write at $2.13 beside those rates. The FAQ states the per-1M unit for input and output. It does not restate a unit on the cache lines, so this page does not invent one. Context is 1M tokens. Max output is 128K. The FAQ says billing is from the SandBase balance and that a separate Anthropic account is not required.

Image, video, and audio models on the same balance use their own units. The homepage discount table is not copied here. For a coding agent, SKILL.md is the setup line. Ask it to show fields and price before a run. Pricing puts that read at $0.

The shared 100 is not every endpoint

Xiaohongshu note search (xiaohongshu/app-v2/search-notes) was $0.01 per call. The page says the first 100 calls per day are free, shared per organization, reset at 00:00 UTC, then pay per call. Its pricing note: $0.01 per successful call, failed calls not charged (including a lookup whose target does not exist), included in the organization’s daily free quota.

PGY creator list (xiaohongshu/pgy/blogger-list) was $0.02 per call. The FAQ says it is billed from the balance and that there is no subscription. The fetched page did not include the free-allowance strip note search shows. Treat a successful call as $0.02 unless a later inspect says otherwise. Inspect was not called, and no remaining-quota counter was read. Eligibility on a page is not a count of calls left today.

Model calls do not spend the 100. Five note searches inside the allowance can be $0 on the data meter and still leave a Sonnet charge.

Sandboxes, for now

The sandbox page: creating, running, and stopping does not touch the balance for now. Fair-use may apply. A price will be announced before it changes. Models and APIs the agent calls are billed as usual. E2B-compatible detail stays in the sandbox comparison. Hosted agent runs stay in the OpenAI Agents API note. The runtime row and the model row are not the same charge.

Failed calls, then Activities

A failed model or API call is $0, and Activities shows status and cost. The homepage points at Activities in the Console for inputs, outputs, status, and recorded costs. A forecast that never meets a row is still a sketch.

One small loop, priced as a sketch

Illustrative. Not a quote, and not a run. Token counts are bounds so the arithmetic is visible. Recompute from the card on the day you spend.

Shape: five successful note searches, one successful PGY creator-list call, one Sonnet 5.5 brief, sandbox cleanup.

Xiaohongshu app-v2/search-notes — $0.01 per call with the shared First 100 calls per day free line.

• Five xiaohongshu/app-v2/search-notes calls still inside the org’s remaining free calls: $0. If that UTC day’s allowance is already gone: 5 × $0.01 = $0.05. The remainder was not read.
• One xiaohongshu/pgy/blogger-list call: $0.02, because that page did not claim the free strip.
• A failed extra search: $0. It is not one of the five.

Ordinary input and output only. Cache lines are not applied.

model = (input_tokens * 1.70 + output_tokens * 8.50) / 1000000

Low bound, 4,000 input and 800 output: $0.0136. High bound, 20,000 input and 2,000 output: $0.0510. Sandbox create, run, and stop: $0 on the current line. Reading the catalog before the loop: $0.

The $0.07 is $0.05 of note search plus $0.02 of PGY. The spread is the token bound, not a measured prompt. Price a video shot from the video post, not from this table.

Bound the loop before it runs

The stop belongs in the product. Cap pages. Cap how many detail calls one result may fan out into. Set max_tokens on the brief. The July piece on per-call versus token pricing is the architecture: fetch with a per-call API, filter, then call a model. Its scenarios are not recomputed here.

One balance, a wallet, a token cap, or three vendors

AI agent API budget control is choosing which of these you are missing.

A subscription you already pay can beat a meter when its quota covers the volume. A token controller can sit in front of Sonnet while data calls stay on SandBase. None of these is “the cheapest.”

FAQ

What is pay-per-call AI API pricing for agents, and when does it beat a subscription?

It charges a successful unit: a catalog amount for a data call, or the card’s token, image, video, or audio rate for a model request. SandBase Build has no monthly floor, so it fits bursty, experimental, or multi-tenant agents. A subscription fits stable volume past a break-even you calculated, or a fixed line finance wants. Scale is custom, with no dollar amount on the pricing page. Either path needs a hard stop: the balance, a daily call bound, or a controller in the app.

How do I budget a multimodal agent that uses models, data APIs, and a sandbox?

Add three numbers. The live model card. The catalog price of each successful data call, after the shared 100 free eligible calls per organization per UTC day — and only for endpoints whose page says they are in that pool. Sandbox create, run, and stop at $0 for now, while calls inside the run still bill. Discovery and failures are $0. Cap the loop, run it once, read Activities.

How is this different from OpenAI’s spending controller or from ATXP and x402?

The cookbook reserves a worst-case token cost and settles the actual cost. Hosted tools and other charges are outside it, and its sample prices are fictional. ATXP and x402 let an agent pay per tool call from a wallet or HTTP 402, often with no classic API key. SandBase is one SANDBASE_API_KEY and one balance for model cards and catalog APIs, plus the current free sandbox and the shared free data calls. Use the controller for token overspend inside a run, a payment rail when the service is not on this catalog, and the balance when the meters should be one bill.

What to open next

Open pricing. Read one data API page and one model card. Run a loop with a page cap and a max_tokens cap. Then open Activities and compare status and cost with the sketch. If the row and the card disagree, the row is what that call cost.

Left on their own pages: per-call versus token architecture, LLM pricing, video cost, the one-key stack, and the sandbox comparison.