Short answer: when Cursor says “you’ve hit your usage limit,” the usage included in your plan for the current period is gone. It is not a bug and it is not your context window. On the current X Subscription plans (Free, Plus, Premium, Super, Ultra) that period is one week; on legacy Cursor plans (Hobby, Pro, Pro+, old Ultra) it is your monthly billing cycle. You can wait for the reset, switch to a model that costs less per token, pay for extra usage with a spending cap, bring your own API key, or move the task to another agent until the pool refills. This guide shows how to tell which situation you’re in, a small calculator for why some models drain the pool five times faster, and the settings that stop it from happening again mid-week.
Last updated: November 4, 2026. Plan and pricing facts come from Cursor’s own help center, Models & Pricing docs and pricing page, read today. I also went through recent threads on the Cursor forum, r/cursor and Hacker News where people hit this exact message. The cost numbers below come from a script run on my Linux test machine against Cursor’s published per-token rates; they are estimates, not a bill.
What “You’ve hit your usage limit” actually means
Cursor meters usage by what each request costs to run, not by a simple message count. Every model has a per-million-token price for input, cached input and output, and your plan includes a pool of that spend. When the pool is empty, Cursor shows a notification in the editor and stops sending requests that would bill against it.
The wording varies a little by plan and version. Forum posts quote the full line as “You’ve hit your usage limit. Upgrade for more usage. Get more credits on higher plans.” Some people see a sibling message asking them to switch models instead. All of them mean the same thing: the included allowance for this period is used up.
Two things it does not mean:
- Your chat is too long. A full context window gives a different error and is fixed by starting a new chat. If you are fighting tool-call failures rather than billing, see the Cursor “error calling tool edit_file” fixes instead.
- Your account is broken. Reinstalling Cursor or logging out and back in does nothing, because the counter lives on the server.
First, find out which plan family you’re on
Since October 12, 2026, Cursor is sold as part of the X Subscription, and the older plans are called legacy plans. They meter usage differently, so the fix depends on which one you have.
| X Subscription (current) | Legacy Cursor plans | |
|---|---|---|
| Plans | Free, Plus ($8), Premium ($30), Super ($100), Ultra ($200) | Hobby, Start, Pro, Pro+, Ultra, older Teams seats |
| Included usage | One weekly pool for Cursor models (Grok 4.7, 4.6, 4.5, Composer 2.5), shared with Grok Bot and the Grok apps | Two monthly pools: Cursor Models and Other Models |
| Third-party models (Claude, GPT, Gemini) | Not in the pool; Premium and up pay API list price from prepaid credit | Billed from the Other Models pool |
| When it resets | Rolling 7 days from when your account moved to the plan | Your monthly billing date |
| Where to check | Usage at grok.com/dashboard, or your editor settings | Spending tab in the Cursor dashboard |
| Keep going after the limit | Prepaid credit (top-ups) | On-demand usage |
Unused usage does not roll over on either kind of plan. Cursor also says requests are never downgraded in quality or speed when you hit the limit: they stop or move to paid usage, they don’t quietly get worse.
One detail people miss on the X Subscription: the weekly pool is shared with Grok. If you also chat with Grok, generate images with Imagine or run Grok Bot on the same account, that comes out of the same allowance your editor uses. In an October 20 forum update Cursor said it was investigating reports of pools draining faster than expected, and that some of that consumption appeared to come from newer included features such as Grok Imagine.
When does the Cursor usage limit reset?
On the X Subscription the pool refreshes weekly, but not at midnight and not at one shared time. A Cursor staff member explained on the forum (October 22) that each account runs on a rolling seven days from the moment it moved onto the plan, so it resets at the same time of day, on the same weekday, every week. The Usage page shows the reset date in your local timezone but not the time, so the reset can land late in the day on that date. There’s an open request to show the exact time.
On legacy plans the counter resets on your billing date each month. If you subscribed on the 15th, it resets on the 15th. If you burn the pool in week one, you wait about three weeks, which is the main complaint people had about monthly pools before the switch.
A quick habit that saves confusion: the first time you hit the limit, write down the day and approximate hour your pool came back. On the weekly plans that time holds every week.
Why the pool ran out so fast
Most “I barely used it” stories on r/cursor and the forum come down to model choice. The same agent session can cost very different amounts depending on which model and mode runs it. Cursor publishes the per-token rates, so I wrote a tiny script that prices one session at each rate.
#!/usr/bin/env python3
"""Estimate what one Cursor agent session costs at Cursor's published per-million-token rates.
Usage: python3 burn.py INPUT_TOKENS CACHED_SHARE OUTPUT_TOKENS
Rates: cursor.com/docs/models-and-pricing (checked 2026-11-04). Edit RATES when they change."""
import sys
RATES = { # model: (input, cache_read, output) USD per 1M tokens
"Composer 2.5": (0.50, 0.20, 2.50),
"Composer 2.5 (Fast)": (3.00, 0.50, 15.00),
"Grok 4.7": (2.00, 0.50, 6.00),
"Grok 4.7 (Fast)": (4.00, 1.00, 12.00),
"DeepSeek V4.1 Flash": (0.30, 0.006, 1.20),
"Claude Sonnet 5.5": (2.00, 0.10, 10.00),
"Claude Opus 5.5": (4.00, 0.20, 20.00),
}
inp, share, out = int(sys.argv[1]), float(sys.argv[2]), int(sys.argv[3])
cached = inp * share; fresh = inp - cached
print(f"Session: {inp:,} input tokens ({share:.0%} cache reads), {out:,} output tokens\n")
base = None
for name, (i, c, o) in RATES.items():
cost = (fresh * i + cached * c + out * o) / 1e6
base = base or cost
print(f"{name:<22} ${cost:6.2f} {cost/base:4.1f}x Composer 2.5")Here is the real output for a made-up but typical long agent session: 2 million input tokens (agents re-read files constantly, so most of that is cache reads) and 60,000 output tokens.
$ python3 burn.py 2000000 0.85 60000
Session: 2,000,000 input tokens (85% cache reads), 60,000 output tokens
Composer 2.5 $ 0.64 1.0x Composer 2.5
Composer 2.5 (Fast) $ 2.65 4.1x Composer 2.5
Grok 4.7 $ 1.81 2.8x Composer 2.5
Grok 4.7 (Fast) $ 3.62 5.7x Composer 2.5
DeepSeek V4.1 Flash $ 0.17 0.3x Composer 2.5
Claude Sonnet 5.5 $ 1.37 2.1x Composer 2.5
Claude Opus 5.5 $ 2.74 4.3x Composer 2.5The session size is an example, not a measurement from my account. Cursor doesn’t publish exactly how each model draws down the included pool, but it does say model selection changes how fast you use it, and the published rates are the best public guide. The pattern is what matters:
- Fast mode is the silent killer. Fast variants cost roughly 2x to 6x the normal model. In a June r/cursor thread, a Pro user who thought their limit had been cut turned out to be running Composer 2.5 Fast all the time; several replies pointed out it costs about six times regular Composer.
- Subagents can pick their own model. Cursor’s docs note that a subagent can run a named third-party model even while your picker still shows Auto, Grok or Composer, and those requests bill as third-party usage.
- Long context costs more. Grok 4.7 above 256k input tokens bills at 2x, and huge chats re-send a lot of context on every turn.
- Grok outside the editor. On the X Subscription, Grok chats, images and Grok Bot share the pool.
If you want the token-level version of these habits, most of the tactics for reducing Claude Code token usage work the same way in Cursor: smaller context, fresh chats per task, and no giant files pasted in.
8 ways to keep coding after the limit
1. Wait for the reset (and know exactly when it is)
Free, and the right answer if the reset is a day away. Check the date under Usage at grok.com/dashboard (X Subscription) or the Spending tab (legacy). Use the wait for planning, reviews and writing tests by hand.
2. Switch to a cheaper Cursor model
On legacy plans, running out of the Other Models pool doesn’t lock you out of Cursor’s own models. Cursor staff have said on the forum that Composer and Cursor’s Grok models keep working from their separate pool. On the X Subscription everything Cursor-made shares one pool, so switching to Composer 2.5 (not Fast) mostly helps you stretch what’s left. From the table above, Composer 2.5 is the cheapest Cursor-made model by a wide margin.
On Auto, use Cost mode. Since July, Auto has Cost, Balance and Intelligence modes; Cost is the classic Auto and bills as a Cursor-model request whatever model serves it. Individual plans only have Cost mode, but if you’re on a team, check which one is selected.
3. Turn off Fast mode and drop effort
If you only change one setting, make it this one. Fast is worth it when you are actively waiting on a short answer, not for a background refactor. On Premium and higher you can choose Fast and effort levels; Plus runs fixed settings (Fast off, medium effort).
4. Pay for extra usage, with a cap set first
On the X Subscription, extra usage comes from prepaid credit that you buy up front. Cursor charges you when you buy credit or when Auto Top-up runs, not afterwards, and each top-up stays valid for 365 days. Before you buy anything, set a cap:
- Go to grok.com/dashboard/billing
- Under Additional usage credits, find Monthly additional usage limit and click Edit
- Enter an amount and save
When you reach that cap, paid usage pauses until next month even if you still have credit. Enforcement isn’t instant, so you can go slightly over.
On legacy plans the equivalent is on-demand usage, and here’s the trap people describe on Hacker News: on-demand is pay-as-you-go billed after the fact, not a prepaid balance. One user explained how they kept using an expensive Claude thinking model after their included usage ran out, not realizing they had moved to per-token billing, and found out from the invoice. If you enable on-demand, set a monthly spend limit in the Spending tab at the same moment.
5. Bring your own API key
On individual plans (Premium, Super, Ultra and legacy Pro, Pro+, Ultra), requests made with your own API key don’t draw from your included usage or prepaid credit; the provider bills you directly. Add keys under Cursor Settings > Models for OpenAI, Anthropic, Google, Azure or AWS Bedrock. Three catches from Cursor’s docs: custom keys only work for chat models (Tab still uses Cursor’s own), Cursor’s zero data retention policy doesn’t apply to your own keys, and Plus doesn’t allow your own keys at all. On Teams and Enterprise there’s also a Cursor Token Rate of $0.25 per million tokens on eligible models, even with your key.
6. Use the cheapest model in the list for grunt work
Cursor’s model list includes DeepSeek V4.1 Flash (hidden by default, so you have to enable it in the model settings) at $0.30 input, $0.006 cached input and $1.20 output per million tokens. On Premium and up it bills from prepaid credit like any third-party model, but as the calculator shows, it’s by far the cheapest option for the same session. To be clear about the trade: it isn’t the smartest model in the picker, it’s the cheapest. I’d use it for renames, test scaffolding, docs and log reading, and switch back to a stronger model for tricky debugging.
Outside Cursor, DeepSeek’s own API lists the same Flash model at $0.30 input and $1.20 output per million tokens at peak, with off-peak hours at half price. That’s the route I’d take if you want a cheap lane in a terminal agent, and the Claude extra usage cost guide shows that setup.
7. Hand the task to another agent until the reset
If you already pay for ChatGPT, Codex runs on that plan. If you don’t want another subscription, open-source agents like Cline or OpenCode with a cheap API key keep you moving for a few dollars; I compared them in free Claude Code alternatives. For a longer view of what to switch to, see Cursor alternatives and Claude Code vs Cursor.
Your project rules travel better than you think. Cursor reads AGENTS.md, and so do Codex and most open-source agents, so keep shared instructions there rather than only in Cursor-specific rules.
8. Upgrade only after you know your weekly burn
Premium has 4x the Plus usage, Super 15x and Ultra 50x. Upgrading is the easiest fix and the most expensive one. Check your usage page at the end of two normal weeks first. If you hit the limit once in a rare crunch, top-ups with a cap are cheaper than moving up a tier for good.
A handoff prompt so the limit doesn’t kill your momentum
The worst part of hitting the limit mid-task is losing the agent’s working context. When you see the usage bar getting close (or right after the notification, using any model you still can), ask for a handoff note:
We're about to pause this task. Write HANDOFF.md in the repo root with:
1. The goal of the current task in one sentence.
2. What is done, with file paths.
3. What is half-done, and the exact next step.
4. Commands to run tests and the current failing test, if any.
5. Decisions we made and why (one line each).
Keep it under 40 lines. Don't change any other file.Then any agent, in Cursor after the reset or somewhere else right now, can start with “Read HANDOFF.md and continue from the next step.”
A rules file that keeps the pool from draining
Put this in .cursor/rules/usage.mdc (or the equivalent section of AGENTS.md). It won’t change prices, but it cuts the wasteful re-reading that burns tokens:
---
description: Keep agent sessions cheap
alwaysApply: true
---
- Before editing, list the files you plan to touch and wait for my OK if it's more than 5.
- Read only the files you need; never read lockfiles, build output, or node_modules.
- Prefer targeted edits over rewriting whole files.
- Run the narrowest test command that covers the change, not the full suite.
- If a fix fails twice, stop and summarize what you tried instead of looping.Combine it with one chat per task. A chat that has been running all afternoon re-sends a lot of history on every request.
Is there free Cursor for students in 2026?
Not in the old form. Cursor stopped new sign-ups for its student discount (the free year of Pro that ran through SheerID verification) on June 25, 2026, saying the program had become a target for fraud. If you redeemed it before then, you keep that rate until the plan expires; after that the subscription continues at the regular price, which for legacy Pro is $20 a month, unless you cancel. Put a reminder on that date.
What students can do now, according to Cursor’s help center and students page:
- Anyone can use the Free plan. It’s limited, and it’s the plan where students hit “you’ve hit your usage limit” most often.
- Undergraduates can get credits and discounts at Cursor’s on-campus and online events, which started this fall. There’s a campus newsletter for early access.
- Master’s students, PhD candidates, researchers and educators can request credits through a form; it’s reviewed, not automatic.
Two warnings. Don’t buy “student accounts” or codes from resellers: Cursor says subscriptions are sold only through its own site and resold accounts can be suspended. And if you’re a student on the Free plan, a forum thread from September noted that the Free plan’s usage percentage can under-report, showing around half used when you’ve actually hit the limit, so don’t trust the number to plan a deadline. If the Free limit is too tight for coursework, the cheap-API agents in option 7 are the realistic free-ish route.
My take
The limit itself is fair: a weekly pool is better than a monthly one for anyone who works in bursts, and Cursor tells you the reset date. What catches people is the billing surface around it, Fast modes, subagents picking their own models, Grok sharing the pool, and on legacy plans the post-paid on-demand switch. For a solo founder on a budget, the setup I’d use is: Composer 2.5 or Auto Cost as the default, Fast off, a spending cap set before any top-up, a cheap model for grunt work, and a handoff note habit. If you want to see how Cursor fits a whole monthly budget, I break that down in the real monthly cost of an AI indie dev stack.
FAQ
How long does Cursor’s usage limit last?
On the X Subscription, until your weekly pool resets, which happens on a rolling seven days from when your account joined the plan. On legacy plans, until your next monthly billing date. The exact date is on your usage page.
Why does Cursor say I hit the limit when the usage bar isn’t full?
On the Free plan the displayed percentage can under-report actual usage, so the limit can arrive while the bar shows around half. On paid plans, check whether you’re looking at the right pool: legacy plans have separate Cursor Models and Other Models pools.
Does Auto mode count toward the usage limit?
Yes. Auto isn’t unlimited. In Cost mode it bills as a Cursor-model request from your included pool. On Teams and Enterprise, Balance and Intelligence bill at the price of whatever model the router picks, which can be a third-party model.
Will Cursor charge me automatically after I hit the limit?
On the X Subscription, only from prepaid credit you’ve bought, and Auto Top-up is off until you turn it on. On legacy plans, if on-demand usage is enabled, further use is billed per token after the fact, so set a spend limit.
Can I use my own OpenAI or Anthropic key to avoid the limit?
On individual Premium, Super and Ultra plans (and legacy Pro, Pro+, Ultra), yes for chat models: those requests are billed by your provider and don’t use your pool. Plus doesn’t support your own keys, and Tab completions always use Cursor’s models.