Composer 2.5 API pricing: what Cursor's coding model costs per million tokens, Fast and standard

Composer 2.5 is Cursor's coding model, released May 18, 2026, and it comes in two servings with two prices. On UnificAlly the standard Composer 2.5 API costs $0.05 per 1M input tokens and $0.25 per 1M output tokens. The low-latency Composer 2.5 Fast API runs the same weights on faster serving at $0.30 in and $1.50 out. This post is the cost breakdown: the full rate card, what an agent loop costs at 100, 1,000 and 10,000 runs a month, where each variant belongs, how the price lines up against the other coding models on the platform, and the exact request both routes accept.

TL;DR: Composer 2.5 bills per token with no subscription. Standard is $0.05 / $0.25 per 1M tokens (input / output); Fast is $0.30 / $1.50, six times the standard rate for the same answers delivered about a third faster. A typical agent step of 50,000 input and 5,000 output tokens costs about $0.0025 plus $0.00125 on standard, or $0.015 plus $0.0075 on Fast. Our call: run unattended agents and CI helpers on standard, and pay for Fast only where a person is watching the cursor blink. The model scores 79.8% on SWE-bench Multilingual and 69.3% on Terminal-Bench 2.0, within a point of Claude Opus 4.7 on both, which makes standard Composer 2.5 the cheapest near-frontier coding model you can call today.

How much does the Composer 2.5 API cost?

Both variants bill per million tokens, separately for input and output, and the rates below refresh from the live price list on every deploy. There is no cached-input rate on either route and no reasoning or thinking meter: Composer 2.5 runs one way, so output tokens are the visible answer and nothing else.

Two things to read off the table. First, the gap between the variants is a flat multiple on both meters: Fast costs six times standard on input and six times on output, so the ratio of your bill does not depend on how chatty the model is. Second, standard Composer 2.5 is priced in the same band as the small models from other labs while scoring like a flagship, which is the whole reason to care about it. Rates for every model side by side are on the pricing page.

Composer 2.5 cost per month at 100, 1,000 and 10,000 agent runs

The rate card is per token; your bill is per task. The table below uses one reference task, an agent step that sends 50,000 input tokens (a growing transcript, tool results, the files in context) and returns 5,000 output tokens (a diff, a plan, a command). Multiply by your real run count and token sizes; the shape of the result does not change.

Add the two columns for a variant to get its monthly total. At 10,000 runs a month the standard route is a small line item and the Fast route is a real budget decision, which is the point of having both: route the long, unattended work (overnight refactors, test triage in CI, batch code review) to cursor/composer-2.5, and reserve cursor/composer-2.5-fast for the sessions where latency is the product. Input dominates both bills because agent transcripts grow every turn, so the cheapest optimisation is trimming what you resend, not shortening the answers.

Composer 2.5 Fast pricing vs standard: what the six-times premium buys

Cursor describes Fast and standard as the same model on different serving, and the independent evidence agrees. A 110-run skills evaluation timed Fast at 59 seconds per task on average against 87 seconds for the standard variant, with quality scores within a point of each other. So the premium buys roughly a third off the wall clock and nothing else: no extra capability, no larger context, no thinking mode. That makes the decision mechanical:

• Someone is waiting on the answer (in-editor assistant, debugging chat, a short agent run a developer is watching): Fast. The latency is the feature and the per-session cost is cents.
• Nobody is waiting (CI helpers, overnight agent loops, bulk review, batch migrations): standard. Same output, a sixth of the bill.
• Mixed pipelines: default to standard and switch the model id to Fast only on the interactive path. The two routes take identical requests, so the switch is one string.

Composer 2.5 benchmarks: is the rate worth it?

The price only matters if the model holds up, and Cursor's published numbers say it does. Composer 2.5 scores 79.8% on SWE-bench Multilingual and 69.3% on Terminal-Bench 2.0, within a point of Claude Opus 4.7 on both, and 63.2% on CursorBench v3.1 hard tasks, above the default settings of Opus 4.7 and GPT-5.5 at a lower average cost per task. Against its predecessor the jump is large on every axis Cursor reports.

The losses stay in. Terminal-heavy work trails the best frontier result: GPT-5.5 scores 82.7% on Terminal-Bench 2.0 against Composer 2.5's 69.3%. CursorBench numbers come from Cursor's own harness, so treat them as directional. And there are no reasoning-effort or thinking controls at all, so tasks that lean on deep multi-step reasoning outside of code do better on a thinking-capable model. For the thing it was trained on, multi-file edits, terminal commands and codebase-wide search in a loop, the scores justify the rate several times over.

How Composer 2.5 pricing compares with other coding models

Per 1M tokens on UnificAlly today, input and output, for the models a coding agent would plausibly route between:

Standard Composer 2.5 is the lowest output rate in that set and sits next to DeepSeek V4 Flash on input, while benchmarking next to models that cost an order of magnitude more per output token. Grok 4.6 is the closest priced rival with a stronger terminal and CursorBench record, and it is the one to test if Composer's Terminal-Bench gap shows up in your tasks. Claude Sonnet 4.6 and GPT 5.4 earn their rates on reasoning outside code and on cached, very long contexts, neither of which Composer 2.5 offers. Kimi K3 is the pick when a run needs the 1M-token window.

How to call Composer 2.5 at either price

Both variants run through the OpenAI-compatible POST /v1/chat/completions endpoint, and the Responses and Messages formats are supported too. The request below is the standard route; change model to cursor/composer-2.5-fast for the low-latency serving and nothing else moves. Set "stream": true to receive tokens as they generate, which is the natural fit for the Fast variant. Full field reference: docs.unifically.com/models/llm/cursor/composer-2.5-fast.

curl -X POST https://api.unifically.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "model": "cursor/composer-2.5",
    "messages": [
      {"role": "user", "content": "Explain this error: TypeError: Cannot read property of undefined"}
    ]
  }'

The response comes back synchronously with the completion and a usage block with the input and output token counts, which is what the bill is computed from. Function calling works on both routes for agent loops. Try the request first in the Composer 2.5 Fast playground, where every call is priced live before it runs.

Composer 2.5 FAQ

How much does Composer 2.5 cost per million tokens?

On UnificAlly, standard Composer 2.5 costs $0.05 per 1M input tokens and $0.25 per 1M output tokens. Composer 2.5 Fast costs $0.30 per 1M input and $1.50 per 1M output. Billing is pay-per-use with no subscription and no cached-input meter.

What does Composer 2.5 Fast cost compared with standard?

Six times the standard rate on both input and output, for the same model served faster. An independent 110-run evaluation timed Fast at 59 seconds per task against 87 for standard with quality within a point, so the premium buys latency only. Use Fast when a person is waiting and standard when the job runs unattended.

What does a month of Composer 2.5 agent runs cost?

Using an agent step of 50,000 input and 5,000 output tokens, 1,000 runs cost about $2.50 in input plus $1.25 in output on standard Composer 2.5, or $15 plus $7.50 on Fast. Input dominates because transcripts grow every turn, so trimming what you resend saves more than shortening answers.

Is there a cheap way to try the Composer 2.5 API?

Every new UnificAlly account gets a $0.50 signup balance with no subscription. At the standard rate that balance covers hundreds of agent steps of the size above, enough to run a real task through the model before adding funds.

Is Composer 2.5 good enough to replace a frontier model for coding?

For agentic coding, the published numbers say yes: 79.8% on SWE-bench Multilingual and 69.3% on Terminal-Bench 2.0, within a point of Claude Opus 4.7 on both. It trails GPT-5.5 on Terminal-Bench (82.7%), has no thinking mode, and Cursor's CursorBench figures come from Cursor's own harness, so keep a thinking-capable model for reasoning-heavy work outside code.

Does the Composer 2.5 price include a context cache?

No. Neither Composer 2.5 route has a cache-read rate on UnificAlly; every input token bills at the input rate. If your agent resends a large, stable prefix every turn, a model with prompt caching such as Claude Sonnet 4.6 or Kimi K3 can come out cheaper on that specific workload even at a higher list rate.

What will change this post

We will update the rate table and the comparison when Cursor changes the Composer 2.5 rates or adds a cached-input meter, when a Composer 3 or a thinking-capable Composer variant lands, and when an independent benchmark re-run puts Composer 2.5 on a public leaderboard worth citing. Prices on this page refresh from the live price list on every deploy, so the tokens stay current between those updates.

Related reading on Composer 2.5

• Composer 2.5 Fast API and Composer 2.5 API: playgrounds, parameters, FAQs.
• Grok 4.6 API pricing: the closest-priced coding rival and its CursorBench 3.2 result.
• Kimi K3 API pricing: the open-weight 1M-context option for long runs.
• Claude API pricing: Sonnet and Opus rates with prompt caching.