If you are new to Cursor, the pricing can look complicated because Cursor does not simply charge you based on "how many times you use AI."

The cost depends mainly on which AI model you use, how much you use it, and which Cursor plan you are on.

Think of Cursor like a car rental service:

• Your Cursor plan is your monthly membership.
• AI models are different cars.
• Some cars are cheaper to drive, while others are more powerful and expensive.
• Tokens are the fuel you consume.
• When your included fuel runs out, you can either pay for more or upgrade your membership.

1. What is Cursor Mode?

Cursor allows you to use different AI models directly inside your code editor.

For example, you can ask AI to:

• Write code
• Explain code
• Fix bugs
• Refactor your application
• Create database queries
• Build features
• Analyze errors
• Work on multiple files
• Make changes to your project using Agent mode

The important thing is that different AI models have different capabilities and costs.

Cursor groups these models into two main pools.

2. The Two Cursor Usage Pools

Cursor currently has two separate usage pools:

Pool 1: Cursor Models

This pool contains Cursor's own models, including:

• Cursor Grok 4.6
• Cursor Grok 4.5
• Composer 2.5

These models come with generous included usage depending on your plan.

For most developers, this is the pool you will use regularly.

Pool 2: Other Models

This pool contains models from companies such as:

• OpenAI
• Anthropic
• Google
• Other providers

For example:

• GPT-5.6 Luna
• GPT-5.6 Sol
• GPT-5.6 Terra
• Claude Sonnet 5
• Claude Opus 5
• Gemini 3.1 Pro

These models consume your Other Models usage allowance.

3. What Are Tokens?

This is probably the most important concept to understand.

AI models don't charge you simply because you sent a message.

They measure usage in tokens.

A token is a small piece of text.

For example:

"Create a Laravel API for user registration."

The AI needs to process your request, your existing code, and potentially the response it generates.

This creates:

Input tokens + Output tokens = AI usage

So if you give the AI a huge Laravel project and ask it to modify several files, it can consume significantly more tokens than asking:

"What is dependency injection?"

Understanding AI Model Pricing

When you look at AI pricing, you will often see four numbers:

These are usually priced per million tokens.

Let's break them down.

1. Input

Input is everything you give the AI.

This can include:

• Your question
• Your instructions
• Code you provide
• Files you ask it to analyze
• Previous conversation/context
• Relevant parts of your project

For example, you tell Cursor:

"Fix this Laravel authentication bug."

And Cursor sends your instructions plus relevant code to the AI.

That information is input.

Example

Suppose the model's input price is:

$2 per million tokens

If your request uses 10,000 input tokens:

10,000 / 1,000,000 × $2
= $0.02

So the input cost would be approximately $0.02.

2. Output

Output is what the AI generates in response.

For a coding assistant, output could include:

• Code
• Explanations
• SQL queries
• Suggestions
• Refactored code
• JSON
• Documentation

Suppose a model costs:

$6 per million output tokens

If it generates 10,000 tokens:

10,000 / 1,000,000 × $6
= $0.06

So the output cost would be approximately $0.06.

Why is Output often more expensive?

Generating information is computationally expensive.

That's why you will often see something like:

Input: $2/M
Output: $6/M

The AI charges differently for what it reads and what it generates.

3. Cache Write

This one is slightly more complicated.

Imagine you are working on a large Laravel project.

Every time you ask Cursor something, Cursor may need to provide the AI with a lot of context about your project.

For example:

Laravel project
+ routes
+ controllers
+ models
+ migrations
+ services
+ configuration
+ existing code

Sending the same information repeatedly can be inefficient.

Caching allows some of that information to be stored temporarily so it can be reused.

When information is stored in the cache, that is called a:

Cache Write

In simple terms:

Cache Write = putting information into the AI's reusable memory/cache.

4. Cache Read

Once information has been cached, the AI can reuse it.

Instead of processing the information as completely new input again, it can read the cached information.

That's:

Cache Read

In simple terms:

Cache Read = using information that was already stored in the cache.

This is usually cheaper than sending the same information as completely new input.

For example, suppose:

Input = $2 / million tokens
Cache Read = $0.50 / million tokens

If you repeatedly work with the same project context, using the cache can significantly reduce the cost of processing that repeated context.

5. A Simple Real-World Example

Imagine you are building a Laravel application in Cursor.

You ask:

"Create an API endpoint for registering users."

Cursor might send:

Input

Your instructions + relevant Laravel code.

Then the AI generates:

Output

The controller, request validation, route and other code.

Now you ask:

"Add email verification."

Some of the project context may already be cached.

So instead of treating everything as completely new information, Cursor may use:

Cache Read

to reuse previously processed context.

If Cursor needs to add new information to the cache, that's:

Cache Write

6. Why Cache Pricing Can Be Confusing

You might see pricing like:

At first, this can look confusing.

You might ask:

"Why am I being charged four different prices?"

Because the AI provider is measuring different types of token processing.

Think about it like a database:

• Input = sending data to the database
• Cache Write = storing frequently used data
• Cache Read = retrieving stored data
• Output = generating the result

The exact implementation of caching differs between AI providers, but this mental model is useful for understanding the pricing table.

7. Putting Everything Together

Let's say you use a model with:

During one interaction, suppose you use:

• 20,000 input tokens
• 5,000 cache-write tokens
• 50,000 cache-read tokens
• 10,000 output tokens

The approximate cost would be:

Input

20,000 / 1,000,000 × $2
= $0.04

Cache Write

5,000 / 1,000,000 × $2.50
= $0.0125

Cache Read

50,000 / 1,000,000 × $0.20
= $0.01

Output

10,000 / 1,000,000 × $10
= $0.10

Total

$0.04 + $0.0125 + $0.01 + $0.10
= $0.1625

So that interaction would cost approximately:

$0.16

The important lesson is that you don't simply multiply the model's headline price by the number of times you use it. The actual cost depends on how many tokens are processed in each category.

8. Which One Should You Pay Most Attention To?

As a beginner, focus on these two first:

Input

How much information are you asking the AI to process?

Output

How much information is the AI generating?

These are the easiest to understand.

Then learn:

Cache Read

This can help reduce the cost of repeatedly processing the same context.

Cache Write

This is related to putting information into the cache so it can potentially be reused.

9. Why This Matters When Using Cursor

This becomes especially important when you use Agent mode.

Suppose you ask Cursor to:

"Build a complete payment integration."

Cursor may need to understand:

• Your existing application
• Your database
• Existing controllers
• Routes
• Models
• Configuration
• Payment code
• Documentation
• Your instructions

That's potentially a lot of context.

If you then continue asking:

"Now add callbacks."

"Now add transaction validation."

"Now add retries."

"Now write tests."

Cursor may repeatedly work with a large amount of project context.

This is one reason why Agent-heavy users can consume significantly more AI usage than developers who only use autocomplete or ask small questions.

10. The Easiest Way to Remember It

Think of an AI conversation like this:

Input

"Here is what I want and here is the information you need."

↓

Cache Write

"Store some of this information so we can reuse it."

↓

Cache Read

"Use information we already stored."

↓

Output

"Here is the answer/code I generated."

And because each operation can have a different computational cost, each can have a different price per million tokens.

That is what the four columns in Cursor's model pricing table are telling you.

4. Why Do Different Models Cost Different Amounts?

Different AI models have different capabilities and operating costs.

For example, according to the pricing you provided:

The prices are per million tokens.

So don't look at a price like "$5" and think:

"Every time I use Claude, I pay $5."

No.

It means that processing one million tokens at that rate would cost that amount.

5. Cursor Plans

There are four main individual plans listed in the information you provided.

The important difference is how much AI usage you get.

6. Cursor Pro - $20/month

For most developers, Pro is the starting point worth considering.

You pay:

$20/month

You get:

• Generous Cursor Models usage
• $20 of Other Models usage
• Unlimited Tab completions
• Extended Agent usage
• Bugbot
• Cloud Agents

For example, if you are building Laravel applications and regularly use Agent mode, Pro can be a reasonable starting point.

7. Pro Plus - $60/month

Pro Plus costs:

$60/month

It includes:

$70 of Other Models usage

This is useful if you are a heavier AI coding user.

For example, you might use AI throughout the day for:

• Writing features
• Refactoring
• Debugging
• Writing tests
• Database work
• Documentation
• Code reviews

If you regularly use expensive third-party models, you can consume your Pro allowance relatively quickly.

Pro Plus gives you a larger allowance.

8. Ultra - $200/month

Ultra is designed for very heavy users.

It costs:

$200/month

and includes:

$400 of Other Models usage

This is more suitable for power users who heavily rely on AI agents, automation and multiple models.

For an average developer who occasionally asks AI to write code, Ultra is probably unnecessary.

9. What Happens When You Use Up Your Allowance?

This is an important part of Cursor's pricing.

Suppose you have Pro.

You have:

$20 of Other Models usage

You eventually consume the entire $20.

You have two choices:

Option 1 - Add on-demand usage

You can continue using the models and pay for additional usage.

Option 2 - Upgrade

You can upgrade to a higher plan with a larger included allowance.

Importantly, reaching your included usage does not necessarily mean:

"Cursor stops working."

You can continue through additional paid usage if your account allows it.

10. Why Does Model Selection Matter?

Imagine you ask three different AI models to perform the same task.

You might ask:

"Build a complete Laravel authentication system."

One model might consume relatively little usage.

Another might consume significantly more.

A more powerful model can also generate more expensive output.

Therefore:

Your choice of model affects how quickly your usage allowance is consumed.

This is why Cursor gives you different models instead of forcing you to use one model.

11. Fast vs Normal Models

You may also see models such as:

Grok 4.6

and:

Grok 4.6 Fast

The Fast version is designed to provide faster responses, but according to the pricing you provided, it costs more per token.

For example:

Grok 4.6

Input: $2/M
Output: $6/M

While:

Grok 4.6 Fast

Input: $4/M
Output: $12/M

So you're effectively paying more for speed.

A simple way to think about it:

Normal = cheaper

Fast = more expensive, faster

12. What Is Auto?

Cursor also has an Auto feature.

Instead of manually selecting a model, you can allow Cursor to decide which model to use.

There are three Auto modes:

Auto Cost

Optimizes for cost.

Auto Balance

Attempts to balance cost and intelligence.

Auto Intelligence

Prioritizes intelligence/capability.

This is useful for beginners because you don't always need to understand every model.

You can essentially tell Cursor:

"Choose the appropriate model for me."

13. How Much Usage Do You Actually Need?

This is where things become easier.

Cursor's own guidance from the pricing information you provided is approximately:

Daily Tab users

Usually stay within:

$20/month

Limited Agent users

Often stay within:

$20/month

Daily Agent users

Typically:

$60-$100/month

Power users

People using multiple agents and automation can reach:

$200+/month

So your usage pattern matters more than simply saying:

"I am a developer."

14. What Does This Mean for a Developer?

Imagine three developers.

Developer A - Light AI user

They mostly use autocomplete and occasionally ask AI questions.

Pro is probably enough.

Developer B - Daily AI developer

They use Agent every day to build features, debug applications and modify multiple files.

They might consume:

$60-$100+ of usage per month.

Pro Plus may make more sense.

Developer C - AI-first developer

They spend most of their working day using AI agents and automation.

They may consume:

$200+ per month.

Ultra could make sense for them.

15. The Most Important Thing to Understand

Don't think about Cursor pricing as:

"How many AI messages do I get?"

Think about it as:

"How much AI computation am I consuming?"

A simple question such as:

"What does this function do?"

might consume very little.

But this:

"Analyze my entire Laravel application, identify architectural problems, refactor the authentication system, update the tests and fix all related errors."

can consume much more.

The second request requires the AI to process much more context and generate much more output.

16. What I Would Recommend for a Developer

If you're just getting started with Cursor:

Start with Pro - $20/month

Use it normally for a month.

Pay attention to:

• How frequently you use Agent
• Which models you use
• How quickly your usage allowance decreases
• How much of your work is being done through AI

If you consistently reach your limits, then consider:

Pro Plus - $60/month

If you're an extremely heavy AI user:

Ultra - $200/month

Don't immediately pay $200 just because Ultra has a much larger allowance.

17. The Simple Mental Model

You can remember Cursor pricing with this:

Plan = Your monthly membership

Model = The AI you choose

Tokens = How much you use

Usage pool = Your allowance

On-demand = Pay for additional usage

Fast = More expensive but faster

Auto = Let Cursor choose the model

And perhaps the most important one:

The more AI work you give Cursor, the more tokens you consume.

So if you are using Cursor primarily for coding, the biggest factor is not just the subscription price. Your development workflow and how heavily you rely on Agent and expensive models will determine your actual monthly cost.