Cursor · AI costs ·

Cursor usage limits: the weekly pool, legacy plans and when they reset

You were working in Cursor and got a notification that you've hit your usage limit. The answer to "when does it reset?" now depends on which kind of Cursor plan you have. Cursor's current docs describe two: plans on The X Subscription, which share one weekly pool, and legacy Cursor plans (Pro, Pro+, Ultra and the rest), which keep two monthly pools. This post sets out what each kind includes, where to check your usage, when it resets, what happens when you run out, and the few things you control.

This guide pairs with Ship-Ready AI Rules, and if you want the next step, read Supabase getSession vs getUser vs getClaims: which to use where.

Checked 17 Oct 2026 against Cursor's own help, docs and pricing pages (listed in Sources). Plan details change, so check those pages before you rely on a number here.

What we did and didn't test. We don't have a Cursor subscription, so every plan detail below is quoted from Cursor's docs, not tested. We haven't hit a limit, watched a reset or seen a bill. The only things we ran ourselves are local: rule file sizes, a token count with an OpenAI tokenizer used as a rough proxy (labelled where it appears), and a small rule-audit script with 14 unit tests, all run with TZ=UTC. We aren't affiliated with or endorsed by Cursor or Anysphere, Inc. Cursor is a trademark of Anysphere, Inc.; other product and model names are trademarks of their owners, used here only to identify them.

Quick answer

  • The X Subscription (Free, Plus, Premium, Super, Ultra): one weekly pool. Cursor's usage page says "your included pool refreshes weekly", and the next reset date is under Usage in your grok.com dashboard.
  • Legacy Cursor plans (Hobby, Start (India only), Pro, Pro+, Ultra, Teams Standard and Premium): two monthly pools. "Legacy Cursor plans: usage resets monthly with your billing cycle." The reset date is on the Spending tab.
  • Either way: "Unused included usage does not roll over on either kind of plan."
  • When you run out: on The X Subscription, wait for the reset, use prepaid credit or upgrade. On a legacy plan, turn on on-demand usage or upgrade.

Two kinds of Cursor plan

Cursor's pricing help page puts it this way: "New customers choose a plan on The X Subscription. If you subscribed to Cursor before it launched, you're on a legacy Cursor plan, and it keeps working as it is."

This comparison is summarised from Cursor's legacy plans page:

Two kinds of Cursor plan
Legacy Cursor plans The X Subscription
Included usage Two pools that refill monthly, one for Cursor's own models and one for other models A single pool that refills weekly, for Cursor's models, shared with Grok
Usage reset Each month, on your billing cycle Each week
Third-party models Covered by the other-models pool on Pro, Pro+, Ultra and Teams Not covered by the pool; on Premium and above they're charged at API rates from prepaid credit
Extra usage On-demand usage, billed at the end of each month Prepaid credit top-ups, which can be set to top up automatically
Spend controls A limit on on-demand spend A monthly cap on additional usage

The weekly pool is shared beyond the editor. The usage page says it is "shared across Cursor, Grok Bot, and the Grok apps", so usage elsewhere on the same subscription draws from the same allowance.

Switching is optional. The pricing help page says: "Switching is optional. Your legacy plan, price, and features continue unless you change or cancel." If you do switch, the legacy plans page says "Your usage moves from two monthly pools to one weekly pool for Cursor models, shared with Grok." It also says "Third-party models stop being included." Cursor calls the switch "optional and permanent", so read both pages before you move.

Which plan am I on, and where do I check usage?

If you pay for Pro ($20/mo), Pro+ ($60/mo) or the older Ultra ($200/mo) and haven't switched, you're on a legacy plan. These are the legacy prices listed on Cursor's pricing help page. New Ultra on The X Subscription is also $200/mo, so go by where you manage billing, not the plan name. Billing for legacy plans lives at cursor.com/dashboard/billing; billing for The X Subscription lives at grok.com/dashboard/billing.

Where to check usage, from Cursor's usage page:

  • The X Subscription: "open Usage at grok.com/dashboard. It shows how much of your weekly pool you've used, the next reset date, and your prepaid credit. Your editor settings show the same remaining usage."
  • Legacy Cursor plans: "go to the Spending tab in your dashboard. It shows real-time usage for both pools, remaining allowance, and any on-demand charges."

Hit your usage limit? When it resets

Cursor's usage page says that when you hit your limit, "You'll see a notification in the editor." When it comes back depends on the plan:

  • The X Subscription: "your included pool refreshes weekly. The next reset date is shown under Usage at grok.com/dashboard." Prepaid credit is separate: "Prepaid credit doesn't reset with your weekly pool; each top-up stays available until used or until it expires (currently 365 days after purchase)."
  • Legacy Cursor plans: "usage resets monthly with your billing cycle. The reset date is shown on the Spending tab." On teams, "all members' usage resets at the same time based on the team billing cycle."

Cursor's pricing page describes the weekly design like this: "Your allowance refreshes weekly, so one heavy day never wipes out your whole month." The flip side, which the docs don't spell out but which follows from the reset rules, is that a weekly pool can run out mid-week and a monthly pool can run out mid-month. Neither carries unused usage forward.

What happens when you run out

On The X Subscription, the usage page lists three options: "keep working from your prepaid credit, wait for your weekly pool to reset, or upgrade to a higher plan." Top-ups are paid up front. The usage-based charges page says "You're charged when you buy credit or when an automatic top-up runs, not in arrears", and Auto Top-up is "off until you turn it on."

To cap paid extra usage, set a monthly additional usage limit at grok.com/dashboard/billing. The spend limits page says it "counts paid additional usage you consume, not the prepaid credit you buy", and "When you reach the limit, additional usage pauses until the next month or until you raise it, even if credit remains."

On a legacy plan, the usage page says: "enable on-demand usage (pay-as-you-go) or upgrade to a higher plan." On-demand usage is opt-in for individuals: "Individual plans (Pro, Pro+, Ultra): On-demand usage must be explicitly enabled in your settings." It's "billed monthly in arrears at the same per-model rates as included usage, with no change in quality or speed." On the legacy Hobby (free) and Start (India only) plans, on-demand usage is "Not available. AI features pause until the pool resets."

Two points about spend limits:

  • They are not instant. "Enforcement is not instant, so usage can briefly exceed your spend limit."
  • On legacy plans, raising the limit mid-cycle can cost you. "Raising a limit mid-cycle can make previously credited overage billable." The overages page explains that a small overage before enforcement is held as "a temporary spend-limit credit", and "If you raise the limit in the same cycle, we may bill some or all of that credit, up to the new limit."

What draws from which pool

The usage page says "On either kind of plan, your model selection affects how quickly your included usage is consumed." The models page adds: "Different models draw from the pool at different rates."

  • Third-party models (Claude, GPT, Gemini and others). On The X Subscription they're outside the pool; the models page says they're available "at the model's API list price from the first request, paid from your prepaid credit." Cursor's pricing page also says: "Third Party model usage in Cursor is not included in the monthly prices shown and must be purchased separately." On legacy plans they draw from the Other Models pool, "drawn down at each model's API price."
  • Auto. On individual plans, Auto runs in Cost mode, and "Cost mode (classic Auto) bills as a Cursor-model request and draws from your included pool whatever model serves it."
  • Subagents. These can surprise you: "Subagents can also run a named third-party model while the picker still shows Auto, Grok, or Composer. Those requests bill as third-party usage at that model's list price."
  • Max Mode. "Current plans don't include Max Mode. On legacy request-based plans, Max Mode is billed at the model's API rate plus 20%."
  • Your own API key. On individual plans, "Your provider bills you directly for the model cost, and those requests don't draw from your included usage or prepaid credit."

If you're also paying for these models directly, in an app you build, our AI API cost calculator estimates a monthly API bill for that app. It doesn't model Cursor's pools.

What you control: model choice, spend caps and always-applied rules

Cursor doesn't publish a per-request usage figure we could test, so this section sticks to what the docs say and what we measured locally.

  1. Model choice. This is the lever Cursor names. On The X Subscription, the usage-based charges page suggests: "Use Cursor models: Grok and Composer draw from your included pool instead of prepaid credit."
  2. Spend caps. Leave Auto Top-up off or set a monthly additional usage limit (The X Subscription), or keep on-demand off or set a spend limit (legacy). Both are covered above.
  3. Rules that load in every chat. Cursor's rules docs say "When applied, rule contents are included at the start of the model context", and "If alwaysApply is true, the rule will be applied to every chat session." Rules with alwaysApply: false load only when a matching file is in context, when the Agent decides the description is relevant, or when you @-mention them. Cursor's own guidance is "Keep rules under 500 lines".

We don't know how much of your pool a given rule uses, and we haven't measured any usage saving from trimming rules. What we can say is that an always-applied rule puts its whole text into the context of every chat, so it's worth knowing which of your rules are always-applied and how long they are. This script lists them.

A rule-audit script

Save it as audit-rules.ts and run it from your project root:

npx tsx audit-rules.ts .cursor/rules

It reads each .mdc file (including subfolders, and skipping plain .md files, which Cursor's docs say the rules system ignores), sorts it into one of the four behaviours from Cursor's frontmatter table, and totals the always-applied rules.

// audit-rules.ts: list which Cursor rules load in every chat.
// Usage: npx tsx audit-rules.ts .cursor/rules
import { readFileSync, readdirSync, statSync } from "node:fs";
import { join, relative } from "node:path";

export type Kind = "always" | "file-match" | "agent-decides" | "manual";
export interface Rule {
  file: string; kind: Kind; lines: number; chars: number; warnings: string[];
}

// Line-based frontmatter read. Globs like **/*.sql are not valid YAML
// scalars (a leading * is an alias), so we don't use a YAML parser.
export function parseRule(file: string, text: string): Rule {
  const warnings: string[] = [];
  const m = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
  const fm: Record<string, string> = {};
  if (!m) warnings.push("no frontmatter: treated as manual");
  for (const line of (m ? m[1] : "").split(/\r?\n/)) {
    const i = line.indexOf(":");
    if (i > 0) fm[line.slice(0, i).trim()] = line.slice(i + 1).trim();
  }
  const always = fm.alwaysApply === "true";
  const globs = (fm.globs ?? "").replace(/^["']|["']$/g, "");
  const desc = (fm.description ?? "").replace(/^["']|["']$/g, "");
  if (fm.alwaysApply && !["true", "false"].includes(fm.alwaysApply))
    warnings.push(`alwaysApply is "${fm.alwaysApply}", not true/false`);
  if (always && globs) warnings.push("alwaysApply: true ignores globs");
  const kind: Kind = always ? "always" : globs ? "file-match"
    : desc ? "agent-decides" : "manual";
  const body = m ? text.slice(m[0].length) : text;
  const lines = text.split(/\r?\n/).filter((l, i, a) =>
    !(i === a.length - 1 && l === "")).length;
  if (lines > 500) warnings.push("over 500 lines");
  return { file, kind, lines, chars: body.length, warnings };
}

export function listRules(dir: string): string[] {
  return readdirSync(dir).flatMap((name) => {
    const p = join(dir, name);
    if (statSync(p).isDirectory()) return listRules(p);
    return name.endsWith(".mdc") ? [p] : [];
  }).sort();
}

export function audit(dir: string): Rule[] {
  return listRules(dir).map((p) =>
    parseRule(relative(dir, p), readFileSync(p, "utf8")));
}

if (process.argv[1]?.endsWith("audit-rules.ts")) {
  const rules = audit(process.argv[2] ?? ".cursor/rules");
  for (const r of rules)
    console.log([r.kind.padEnd(13), String(r.lines).padStart(4),
      String(r.chars).padStart(6), r.file, ...r.warnings].join("  "));
  const on = rules.filter((r) => r.kind === "always");
  console.log(`every chat: ${on.length} rule(s), ` +
    `${on.reduce((n, r) => n + r.lines, 0)} lines, ` +
    `${on.reduce((n, r) => n + r.chars, 0)} chars`);
}

How it decides, following Cursor's frontmatter table:

  • alwaysApply: true is "always". Cursor says globs and description are then ignored, so the script warns if globs are set.
  • alwaysApply: false with globs is "file-match".
  • alwaysApply: false with a description and no globs is "agent-decides".
  • alwaysApply: false with neither is "manual" (only when you @-mention it).

It reads the frontmatter line by line instead of with a YAML parser, because a glob such as **/*.sql starts with *, which YAML treats as an alias. Lines count the whole file; characters count the rule text after the frontmatter. It type-checks under tsc --strict and passes 14 unit tests (each rule kind, quoted values, a missing frontmatter block, CRLF line endings, a non-boolean alwaysApply, the 500-line boundary, nested folders and a skipped .md file).

On a small demo folder with one rule of each kind, it printed:

file-match        7      70  frontend/components.mdc
agent-decides     5      45  migrations.mdc
always            6      88  project.mdc
manual            4      53  release.mdc
every chat: 1 rule(s), 6 lines, 88 chars

What it shows on a real rule set

We ran it on the six Cursor rules in our own AI Rules v2 pack:

always           12     647  00-project.mdc
file-match       17    1260  10-nextjs.mdc
file-match       31    2679  20-supabase.mdc
file-match       21    2054  30-stripe.mdc
always           10     437  40-security.mdc
file-match        8     293  50-testing.mdc
every chat: 2 rule(s), 22 lines, 1084 chars

Two short rules (22 lines, 1,084 characters of rule text) are always applied. The other four (77 lines, 6,286 characters) load only when a matching file is in context.

Rough tokenizer proxy (labelled). We also counted each whole file with OpenAI's o200k_base tokenizer (js-tiktoken 1.0.21): 297 tokens for the two always-applied rules and 1,671 for the other four. Treat this as a rough size comparison only. Cursor's models may count tokens differently, and we have no way to see how Cursor charges a rule against your pool.

"Rate limited by model provider" is a different message

Searches for Cursor limits often include "rate limited by model provider". That message isn't covered on the Cursor usage and pricing pages we read, so we won't guess how Cursor handles it, or say whether it touches your plan's pool. If you call these model APIs yourself, our guide to OpenAI and Anthropic 429 errors explains provider rate limits and which errors to retry.

If you also use Codex or Claude Code

Each tool measures its limits differently, so a side-by-side comparison would mostly compare plan tables that keep changing. For the other two:

Related

Disclosure: this is our own paid product. AI Rules v2 is a Claude Code plugin with guardrail hooks, skills and subagents for Next.js, Supabase and Stripe. It also includes the six Cursor rules measured above: two short always-applied rules and four scoped to matching files. It doesn't reduce or raise your Cursor usage limits, measure your usage or change your billing, and we haven't measured any usage saving from it. The hooks are Claude Code specific; in Cursor you get the rules. It costs $19 (plus VAT where applicable).

Sources (checked 17 October 2026):

Related posts