EN ▾
Get API key

cursorapikey.com/Guide

Cursor API Pricing: $0.15 and $0.50 per 1M Tokens

Cursor API pricing here is simple: $0.15 per 1M input tokens and $0.50 per 1M output tokens, paid from prepaid credit. Below is the arithmetic for real editor workloads, from a single request to a full month.

Updated

Balance scale weighing coins against streaming tokens, illustrating per-token API pricing

Key points

  • Input costs $0.15 per 1M tokens, output costs $0.50 per 1M tokens, with no subscription.
  • A request with 20,000 tokens in and 1,000 out costs $0.0035.
  • Top-ups run from $20 to $500, with +5% from $50, +10% from $100 and +15% from $200.
  • Credit never expires, and failed or refused requests are not charged.

The short answer

If you are weighing cursor api pricing for an editor setup that uses your own endpoint, the model is billing by token and nothing else. There is no seat fee, no monthly plan and no minimum usage. You load credit, requests draw it down, and you can watch the balance in the X-Balance-USD response header.

ItemRate
Input tokens$0.15 per 1M
Output tokens$0.50 per 1M
Failed or refused requestsNot charged
Credit expiryNever

One thing to be clear about: this is a different product from Cursor's own plans. Cursor is an editor with its own billing. This site is a hosted OpenAI-compatible text API that you can connect to Cursor, or to anything else that accepts a custom base URL. For what Cursor itself charges, check Cursor's current pricing page. The setup steps are in the quickstart.

How tokens turn into dollars

A token is a piece of a word. English prose averages a bit over one token per word, and source code often uses more tokens per line than prose because of symbols and indentation. You do not need to count by hand: every response reports usage, and streamed responses report it at the end.

The formula is the same every time:

def cost_usd(input_tokens, output_tokens):
    return input_tokens * 0.15 / 1_000_000 + output_tokens * 0.50 / 1_000_000

print(cost_usd(20_000, 1_000))   # 0.0035
print(cost_usd(2_000, 500))      # 0.00055
print(cost_usd(80_000, 4_000))   # 0.014

Three request shapes cover most editor work, and the numbers show where the money goes:

Request typeInputOutputCost
Quick question about one function2,000500$0.00055
Edit across a few files20,0001,000$0.0035
Large refactor with big context80,0004,000$0.014

In the second row, input is $0.003 and output is $0.0005, so input dominates even though output is priced higher per token. Code assistants read far more than they write, which makes input volume the lever that matters.

Monthly estimates for three kinds of developer

Assume 22 working days in a month. These are illustrations built from the rates above, not measurements of your usage.

Light use: occasional questions

Thirty quick questions a day at $0.00055 each is $0.0165 per day. Over 22 days that is $0.363. Under forty cents for a month.

Daily driver: editing most of the day

Two hundred edit requests a day at $0.0035 each is $0.70 per day. Over 22 days that is $15.40.

Heavy use: large-context refactors

Five hundred requests a day at $0.014 each is $7.00 per day, or $154.00 over 22 days. Few people sustain that, but it shows the ceiling for an agent that stuffs 80,000 tokens into every call.

Compare these with the monthly price of whatever editor plan you use now. Check each vendor's current pricing before you decide, because plans differ in what they include and prices change. A flat plan wins if you use it heavily and predictably. Pay per token wins if your usage is uneven, if you only need an endpoint for some tasks, or if you want to stop paying in months you barely code.

Why conversations cost more than you expect

Chat models are stateless. Each turn, the client resends the whole history, so input tokens grow with every message. Here is a worked example. A system prompt of 1,000 tokens, then 20 turns where each turn adds 300 tokens from you and 300 from the model.

  • Input at turn n is 1,300 + 600 x (n - 1) tokens.
  • Summed over 20 turns: 20 x 1,300 + 600 x 190 = 26,000 + 114,000 = 140,000 input tokens.
  • Output is 20 x 300 = 6,000 tokens.
  • Cost: 140,000 x $0.15 / 1M = $0.021, plus 6,000 x $0.50 / 1M = $0.003. Total $0.024.

The whole 20-turn conversation costs about two and a half cents. Still, you can see the shape: the history is 140,000 input tokens against only 6,000 of output. Long sessions get quadratic in input. Starting a fresh chat when the topic changes is the cheapest optimisation there is.

The context window is 100,000 tokens, prompt plus completion. A request cannot exceed it, so a runaway history will eventually be rejected rather than billed without limit. Trim old turns before you reach that point.

Prepaid credit, bonuses and the trial

You top up with any whole amount from $20 to $500. Bonus credit is added automatically:

Top-upBonusCredit you get
$20none$20.00
$50+5%$52.50
$100+10%$110.00
$200+15%$230.00
$500+15%$575.00

At $0.0035 per edit request, a $20 top-up buys about 5,700 of them. Payment is by crypto (USDT on TRC20, USDC on Base). Because credit never expires, a bigger top-up for the bonus carries no risk of losing the unused part.

To test before paying, claim the trial. After you sign up with Google or with email and password, one click on the API key page adds $0.50 of trial credit, one per person, valid for 7 days, no card required. At the input rate alone that is 3.33M input tokens; at the output rate alone it is 1M output tokens. In edit-request terms it is around 140 requests, enough to judge whether the model suits your code. Trial keys allow 2 concurrent requests and 60 per minute.

Budgeting for a team and finding the break-even point

Shared setups add up linearly. Suppose five developers each send 100 edit requests a day at $0.0035. That is $0.35 per person per day, $1.75 for the team per day, and $38.50 over 22 working days. The rate limits matter more than the money here: a full key allows 8 concurrent requests and 300 per minute in total, so five people working at once will rarely collide, while twenty might.

To compare with a flat monthly plan, work backwards from its price. This uses a hypothetical figure, so replace it with the real price from the vendor's current pricing page. If a plan costs $20 a month, the same $20 buys 5,714 edit requests at $0.0035 (20 / 0.0035). Spread over 22 working days that is about 260 requests a day. If you send fewer than that, per-token billing is cheaper on those numbers. If you send more, the flat plan may win. The calculation also depends on how much context you really send, so measure a few days of your own usage from the reported token counts before drawing conclusions.

Two things the per-token price does not include, to avoid surprises: there is no image, audio or video generation, and no embeddings or fine-tuning. It is text in, text out. Everything on the bill is input and output tokens.

Keeping the bill low

  • Send less context. Include the files the question needs, not the whole repository. Halving input halves the dominant cost.
  • Cap output when you can. max_tokens is optional, but setting it protects you from a rambling answer on a question that needed one line.
  • Ask for the changed part. "Return only the modified function" saves output tokens, and those cost $0.50 per 1M against $0.15 for input.
  • Reset long chats. As the 20-turn example shows, history is where input balloons.
  • Watch the balance header. X-Balance-USD comes back on each response, so a script can alert you at a threshold.
  • Retry freely. Failed and refused requests are not charged.

For the complete table and payment details see the pricing page. If you are comparing editors rather than endpoints, the page on the Cursor alternative describes where a custom-endpoint setup fits.

01

Questions and answers

Is there a monthly fee?

No. You pay per token from prepaid credit: $0.15 per 1M input tokens and $0.50 per 1M output tokens. Nothing is charged when you do not use it.

What does one coding request cost?

A request with 20,000 input tokens and 1,000 output tokens costs $0.0035. A small question with 2,000 in and 500 out costs $0.00055.

Does unused credit expire?

No. Credit never expires, so you can top up once and use it over as long as you like.

Is a failed request billed?

No. Failed or refused requests are not charged.

How does this compare with Cursor's own plans?

They are different products with different billing, so check Cursor's current pricing and compare with your own token counts. This API bills only for tokens used.

Your key is one form away

Create an account, copy the key, change the base URL. That is the whole setup.