Code Generation Pricing: Examples & Companies

What is it

Code Generation Pricing is pricing for AI services whose primary output is generated source code, typically measured in tokens, requests, or completed tasks.

The corpus tags 28 companies under this use case, and they split cleanly into two layers. The model layer — Anthropic (Claude), OpenAI (GPT / Codex), Google (Gemini), and DeepSeek — sells coding-capable models directly on pure per-token APIs with a public rate card and no seat. The product layer — Cursor, GitHub Copilot, Windsurf, Tabnine, Augment Code, and roughly two dozen others — wraps those models in a developer-facing product and has largely converged on hybrid pricing: a fixed per-seat fee plus a metered or credit-based usage layer.

Code generation overlaps with the narrower AI coding tools use case, but it is deliberately broader. It captures API-only model services, autonomous agents like Cognition’s Devin, browser-native app builders like Bolt.new, Lovable, and v0, and execution sandboxes like E2B that run LLM-generated code — not just IDEs. The common thread is that the billable output is code, and code is a high-variance output: a one-line completion and a multi-file agentic refactor sit on the same product surface but can differ 100x in underlying cost.

That cost variance is the central pricing problem. A flat subscription loses money on the power user who runs agents all day; a pure per-token meter scares off the cautious developer who just wants completions. Most product companies in this set have landed on the same answer — bundle a generous baseline into a seat, then meter the overage as credits or tokens — while the model providers underneath race per-token prices toward the floor. A handful of outliers, like Factory, deliberately reject metering altogether in favor of predictable flat rate-limit tiers.

How it works

The unit of billing depends on which layer you buy. The model layer meters raw tokens; the product layer abstracts tokens into credits or a monthly token allotment and stacks them on a seat; a few tools price closer to the completed task, and one prices by rate limits with no meter at all.

The credit and token abstractions do real work because the same prompt costs wildly different amounts depending on which model runs it. Augment Code publishes the spread explicitly: a standard medium-complexity task costs 293 credits on Claude Sonnet 4.6 but only 88 on Haiku 4.5 — a multi-x range on identical work. Credits and per-model token rates let the vendor expose that variance without forcing the buyer to learn each token rate, and let the vendor change underlying economics without renegotiating a plan card. This is the credit-based billing pattern applied to code.

GitHub Copilot made the abstraction unusually legible by pinning 1 AI credit = $0.01 of underlying model cost, so the meter reads in dollars. Critically, it carved code completions and next-edit suggestions out of the meter entirely — they are unlimited on every paid plan and never consume credits — leaving only the expensive agent, chat, and review work metered. Sweep AI makes the same carve-out, bundling unlimited autocomplete into the seat and metering only chat and code generation.

Unit math (v0 shared credit pool): v0 runs four in-house models priced from $1/$5 up to $10/$50 per 1M in/out tokens, with cache tokens priced cheaper. A seat funds a monthly credit balance; each generation drains it at the per-model token rate. Because the seat price is fixed, every v0 price change since launch has happened in the token table — rates roughly doubled in February 2026 with no movement on any plan card.

Unit math (raw model, same work): That same agentic work billed straight against a discounted coding model is far cheaper per token — DeepSeek-V4-Flash cache-hit input runs at roughly one-tenth its cache-miss rate, making reused-context input nearly free. You pay the product layer for product, not for inference.

Companies using this

Twenty-eight companies in the current corpus serve the code generation use case, spanning the per-token model providers (Anthropic, OpenAI, Google, DeepSeek), the hybrid editor tools (Cursor, GitHub Copilot, Windsurf, Codeium, Tabnine), the app builders (Bolt.new, Lovable, v0, Replit AI), and the agents, sandboxes, and open-source runners around them (Cognition, E2B, Aider, Continue.dev). The table below lists each company’s structural choices — pricing model, billing units, and free tier.

Patterns observed

Across these companies, the same structural moves recur — and they differ sharply by layer.

• The product layer has converged on hybrid; the model layer stays pure per-token. Cursor, GitHub Copilot, Windsurf, Continue.dev, and Augment Code all pair a per-seat fee with a usage layer, because per-user cost variance routinely exceeds 3x. Underneath them, Anthropic, OpenAI, and DeepSeek expose one public rate card per model with no seat at all. The same use case produces two completely different pricing shapes depending on whether you sell the model or the product. See the hybrid pricing model theme for the broader pattern.

• The seat increasingly resolves to a credit pool or token allotment. GitHub Copilot, Qodo, v0, Bolt.new, and Augment Code all express paid AI usage as credits or tokens layered on top of the seat — the credit-based billing pattern applied to code. Credits absorb the per-model cost variance that raw tokens would otherwise expose directly to the buyer.

• Completions get carved out of the meter to protect adoption. The high-frequency, cheap action — autocomplete and next-edit suggestions — is left unmetered on every paid plan (GitHub Copilot and Sweep AI both do this), while only the expensive agent, chat, and review work draws down the meter. Pricing the keystroke removes the single biggest psychological barrier to adoption; nobody wants a meter ticking as they type.

• Coding tokens are deflating fast, so the inference under a seat costs less every year. DeepSeek reset the floor and Anthropic and OpenAI cut per-token prices each generation, yet the product-layer seat holds steady even as the tokens it bundles get cheaper — which quietly widens the vendor’s margin. That gap between a falling token cost and a fixed seat is the structural reason editors capture margin at the seat, not the inference. See the token-price-deflation trend.

• Consumer chat and free tiers are the top-of-funnel. Anthropic (Claude.ai Free/Pro/Max), OpenAI (ChatGPT tiers), and Google (free Gemini app with AI Pro / AI Ultra upsell) all run a freemium subscription alongside the pure-usage API, while product builders like Bolt.new (generous free-token allotment) and Cursor (free Hobby) use a generous free tier to seed adoption. The subscription and free tier capture the casual coder; the API and paid seats capture the developer building on top.

• A minority reject metering entirely — either up-market or open-source. Factory prices by flat rolling rate-limit tiers with no overage line, and Tabnine sells the right to run privately (on-prem, VPC, air-gapped) rather than completion volume. At the opposite end, Aider is free and open-source with pure bring-your-own-key token pass-through, and Imbue ships free in beta on a BYOK basis. The meter is a property of the commercial product model, not of code generation itself.

Counterexamples & variants

DeepSeek is the clean counterexample to the hybrid-product model: a pure per-token coding model with no seat, no editor, and no credit abstraction, competing almost entirely on raw price. It proves that the “seat plus credits” structure is a property of the product, not of code generation itself — strip away the product layer and code generation reverts to commodity per-token inference. DeepSeek’s aggressive cache-hit discounting takes that to its logical end: making reused-context input effectively negligible. Aider reaches the same endpoint from the open-source side — Apache-2.0, free, with cost that is pure pass-through to whatever LLM API key you supply.

Factory is the sharpest counter-trend in the set. Almost uniquely, it tried token-based usage pricing for a full year — including a billion-token Ultra tier — then walked it back to flat rate-limit tiers at its Series C. Plus is “~5x the usage of Pro” and Max “~10x,” but neither has an overage line; you buy a usage ceiling and, on hitting it, wait or upgrade rather than getting a surprise bill. While most of the corpus migrates toward usage and outcome metering, Factory ran the experiment and chose predictability. It even folds Droid Computers — the cloud machines that run its agents — into the flat seat, hiding compute that peers would meter by the hour.

Tabnine is a value-metric variant: it prices the right to run the platform privately — SaaS, VPC, on-prem, or air-gapped, with zero code retention — rather than completion volume. It unbundles the seat from inference entirely and lets customers bring their own model for unlimited token usage at no incremental Tabnine charge; when customers do use Tabnine-provided models, the meter is a transparent pass-through (provider price plus a flat 5% handling fee) rather than a marked-up credit. Its autonomous agents are priced by token capacity, not seats.

E2B is a structural variant — it generates value for code generation without billing the code itself. E2B sells the sandbox that runs LLM-generated code, billed per second of running compute, and deliberately decoupled its platform fee from usage credits so marginal cost stays honest. The autonomous-agent variant pushes the other way: Cognition’s Devin is positioned as an autonomous software engineer where the natural unit is a completed engineering task, priced through subscription tiers plus consumption-based credits (Enterprise billed in ACUs). Task cost is the most variable of all, which is exactly why most companies in this set retreat to credit pools that approximate task-based billing while staying simple to meter.

The migration-churn variant is a warning, not a model. Augment Code changed its pricing metric four times in under 18 months — usage credits, “unlimited” subscriptions, user messages, then a pooled credit pool — as it hunted for a unit that matched agentic cost without alienating buyers. Windsurf similarly moved from a credit model to a quota model amid an ownership saga. The instability across both shows how unsettled code-gen pricing still is when output cost varies this much.

What this means for buyers vs vendors

For buyers

Never compare list prices across this category — compare cost per typical workflow. A $20 Cursor plan, a $25 Bolt.new Pro seat, and a raw DeepSeek API all look cheap on paper, but the headline is often a floor: Bolt’s own guidance is that a shipping app realistically needs closer to $50/mo once token reloads are added, and a complex prompt can eat ~200K tokens before you notice. Daily multi-file refactors on a frontier model can push a single developer’s metered usage past their seat fee.

Use a Cursor pricing calculator or equivalent to model your real usage, and in procurement ask three questions: which actions are metered versus bundled (completions are often free, agents rarely are), how credits or tokens convert to dollars and to your specific models, and whether the vendor exposes a live spend dashboard with per-user caps. If you value predictability over raw capability, a flat rate-limit tool like Factory removes bill-shock risk at the cost of a hard ceiling. If you mostly want raw capability and can handle the integration, calling a discounted coding model directly — or running an open-source runner like Aider against your own key — will undercut any product seat. The introduction to usage-based pricing guide covers how to reason about these tradeoffs.

For vendors

If you sell a product, hybrid is structurally correct once per-user cost variance exceeds roughly 3x — but the credit design is where you win or lose. GitHub Copilot’s dollar-legible credit and its decision to make completions free both reduced adoption friction, and v0 kept buyers calm through three metering changes by moving price only in the token table; Augment Code’s four metric changes in 18 months and Windsurf’s credit-to-quota churn show the cost of getting it wrong.

Invest as much in the in-product spend dashboard and per-user caps as in the meter itself — hybrid pricing without spend visibility reads as hostile, and token burn that the buyer can’t predict is the loudest community complaint against tools like Bolt.new. Choose your billing unit deliberately: the right usage metric is the one that tracks the value the buyer perceives, not just the cost you incur — Tabnine prices deployment privacy, Factory prices predictability, and both defend a premium that pure completion-count pricing could not. If you sell the model, you are in a deflationary per-token race led by DeepSeek — compete on price-performance, coding-specific quality, and cache economics rather than headline rate alone.

Explore this theme in the knowledge graph →