Token-Based Pricing: Examples & Companies

What is it

Token-Based Pricing is a billing unit common in LLM and AI products, where customers are charged per input and output token processed.

A token is roughly ¾ of a word. Vendors quote rates per million tokens and almost always split input (the prompt you send) from output (the text the model generates), pricing output several times higher because generating it costs more compute. It is the dominant developer-API unit in the corpus — 66 of the in-corpus companies meter in tokens — because it maps nearly one-to-one to the vendor’s underlying GPU cost, which lets prices fall as that cost falls.

Because tokens track compute so directly, token-based pricing is the most transparent unit in AI — a buyer can multiply their own workload by the rate card and predict the bill. That same transparency makes the token rate the frontier of AI’s price war: when GPU cost falls or a competitor undercuts, it is the number that moves. The pattern spans the whole stack — frontier model APIs, inference clouds, embedding specialists, and coding tools that expose tokens under a credit layer all publish per-token rate cards, priced and compared in the sections below.

How it works

A token bill has more dimensions than the headline rate suggests:

The input/output split is the defining mechanic. Anthropic prices Claude Haiku 4.5 at $1/1M input and $5/1M output, Sonnet 4.6 at $3/$15, and Opus 4.8 at $5/$25 — a clean 5× output multiplier across the line. Cohere prices Command A at $2.50/$10 and Command R at $0.15/$0.60. The ratio itself is a signal of how generation-heavy a model is.

Worked example: a request with 8K input + 2K output on a $5/$30 model (like GPT-5.5) costs (8/1000 × $5) + (2/1000 × $30) = $0.04 + $0.06 = $0.10. Output is 60% of the bill on only 20% of the tokens — which is why response length, not prompt length, usually drives cost. Model your own input/output mix in the OpenAI token calculator or the Anthropic calculator.

Two vendor-native discounts sit on top of the headline rate. Prompt caching bills a repeated prefix far below the cache-miss rate — DeepSeek charges $0.0028/1M for a cache hit versus $0.14 cache-miss on V4-Flash (a 98% reduction), Google prices Gemini 2.5 Pro cached input at $0.13/1M versus $1.25, and xAI caches grok-4.3 input at $0.20/1M versus $1.25. Batch processing runs latency-tolerant jobs asynchronously at roughly 50% off — offered by Anthropic, Mistral AI, Groq and Fireworks AI. Together these mean the effective price a workload pays can be a small fraction of the sticker rate. See choosing the right usage metric for how to pick between token, seat, and outcome meters.

Companies using this

Sixty-six companies in the current corpus meter in tokens: frontier model APIs (OpenAI, Anthropic, Google, xAI, Mistral AI, DeepSeek, Cohere, and the open-weight labs Zhipu AI, MiniMax, Moonshot AI), inference and hosting clouds (Groq, Together AI, Fireworks AI, Baseten, Replicate, DeepInfra, Novita AI), embedding specialists (Voyage AI, Nomic, Jina AI), an aggregator layer (OpenRouter), and app-layer products that expose tokens as one unit among several (Cursor, Codeium, Windsurf, Writer, Perplexity AI). The table lists each rate structure.

Patterns observed

• Input/output split is near-universal, and the ratio is a signal. Almost every token API prices output above input, and the multiplier (commonly 3–6×) reflects how generation-heavy the model is. The clear exception is embedding-only vendors — Voyage AI, Nomic and Jina AI quote a single per-token rate because embeddings produce no generative output.

• Caching and batch discounts are now standard. Cache rates and 50% async batch tiers appear across DeepSeek, Google, xAI, Anthropic, Mistral AI and Fireworks AI, decoupling the effective price of a repeat-context workload from the headline number — see latency-tiered discounts.

• Open-weight labs compete purely on the token rate. DeepSeek, Moonshot AI, MiniMax and Zhipu AI have no seat-based product to hide behind — their entire go-to-market is a lower number on the rate card, and the inference clouds (Together AI, Fireworks AI, DeepInfra) resell those weights per-token, sometimes at prices scaled by parameter count ($0.10/1M under 4B, rising with model size on Fireworks).

• Per-token prices only move down. The deflation is so consistent that re-pricing is an expected event each model generation. OpenAI’s per-capability cost fell ~97× from GPT-4 to GPT-4o mini; xAI cut grok input ~75% from $5/1M at the 2024 grok-beta launch to $1.25 on grok-4.3. See token-price deflation.

• Tokens are the transparent floor under credit abstractions. App-layer products like Cursor convert tokens into credits (its request pool debits at $1.25/1M input, $6/1M output, $0.25/1M cache read), but the token is the honest unit underneath — which is why developer buyers keep asking for the raw rate.

Counterexamples & variants

Not every AI workload is naturally tokenised, and several companies on this page bill tokens for text while metering other modalities differently. Voyage AI’s multimodal models run two meters at once — $0.12/1M text tokens plus $0.60 per 1B pixels, with each image clamped between a $0.00003 floor and a $0.0012 ceiling — because a “token” doesn’t describe an image. xAI tokenises text but prices images from $0.02 each, TTS at $15 per 1M characters, and speech-to-text from $0.10/hour. Deepgram and AssemblyAI appear in the token list for their LLM/understanding features but meter core transcription per minute or per hour, where audio duration — not tokens — is the real cost driver.

The most common variant is tokens hidden behind credits. Cursor denominates its bill in a request/credit pool while tokens drive the underlying cost; Mistral AI runs a two-track model where its Vibe assistant is a flat $0–$24.99/user/month subscription while only the developer API is per-token. This is convenient for the buyer but less transparent on true unit economics — the abstraction lets the vendor change underlying token economics without renegotiating the plan.

A subtler failure mode is context-tier surprise. Some models step to a higher per-token rate above a context-length threshold (Google’s Gemini line historically stepped past ≤200K context), so a workload that grows its prompt can cross into a more expensive band without changing models. Buyers who budget on the short-context headline rate can be caught out when long-context RAG pushes them over the line. For workloads where duration, pixels, or requests track cost better than tokens, forcing a token meter obscures rather than clarifies the bill.

What this means for buyers vs vendors

For buyers

Model cost on output length, not prompt length — output is where the bill concentrates. Before you negotiate a rate, exploit the two free levers first: prompt caching for stable prefixes (system prompts, RAG context) and batch for anything latency-tolerant. Then re-baseline at least twice a year, because prices fall every model generation — a workload priced on last year’s rate card is almost certainly overpaying.

Watch for tokens hidden behind credits. When a product like Cursor bills in a request pool, ask for the underlying per-token debit so you can compare it against a raw API. And check for context-tier step-ups before you commit a long-context workload. Model your real input/output mix in the Cursor calculator or a frontier-model calculator, and read the introduction to usage-based pricing to frame token cost against seat and outcome alternatives.

For vendors

Token pricing is the transparent default developers expect — publish input/output rates openly and add caching and batch tiers to compete on effective price without cutting your headline rate. Open-weight labs like Moonshot AI and DeepSeek have shown the token rate is the entire competitive surface when there’s no seat product to differentiate on, so expect continued downward pressure and design your margin around falling GPU cost rather than a fixed sticker price.

If your workload isn’t naturally tokenised — audio, image, video, embeddings — pick the unit that tracks your cost (minutes, characters, pixels, GPU-seconds) rather than forcing tokens, as Voyage AI’s dual pixel-plus-token meter and Deepgram’s per-minute transcription demonstrate. And decide deliberately whether to pass tokens through transparently or bundle them behind credits: the abstraction buys pricing flexibility but costs you the trust that transparent per-token rates earn with technical buyers. See choosing the right usage metric for the trade-offs.

Explore this theme in the knowledge graph →