Cursor's Bill Disappeared. The Official Answer: Deliberate Design.

Open Cursor’s billing page right now.

You’ll see: “2,847,391 tokens.”

How much money? No idea. It stopped telling you.

July 31st, no announcement, no changelog. Every dollar figure on the usage page replaced with token counts. API cost fields zeroed out. Someone asked if it was a bug. A Cursor employee replied:

“This is deliberate design.”

What happened: an API field going dark

On July 31st, Cursor’s usage API endpoint https://cursor.com/api/dashboard/get-filtered-usage-events started returning zeroed-out values for the following fields:

chargedCents: 0
usageBasedCosts: "$0.00"
tokenUsage.totalCents: (omitted)

This was not a bug. Cursor employee Kevin Neilson confirmed in the forum:

“This is deliberate design.”

Also removed:

• The dollar-amount line chart from the usage page (token counts remain)
• The Cost column from CSV exports (zeroed out)
• Per-request cost fields — completely disabled for Teams self-serve plans

One Teams admin, Kris_Gunnars, reported his team had spent $30,000 in API usage that billing cycle — with no way to break it down by user or model.

The official explanation: dollar amounts on personal plans sometimes showed numbers higher than the subscription price (because included-plan credits were being counted), causing “confusion.” So they removed it.

Why the explanation doesn’t hold

There are 100 ways to fix “confusion.” Add a line of explanatory text. Use different colors to distinguish included credits from actual charges. Add a toggle.

Cursor chose to: delete it entirely.

What makes this worse: the deletion wasn’t surgical. It hit everything:

• Historical data: previous records that showed real dollar amounts now return chargedCents: 0, retroactively.
• Teams plans: these users don’t have the “included credit confusion” problem — they’re on pure API billing. Their data was deleted too.
• CSV exports: the engineering team’s primary cost analysis tool. The Cost column is now all 0.0.

One engineer wrote in the forum:

“Not to verify or track against Cursor subscription — but for example: I was using Cursor Grok 4.5, sent a message, refreshed usage page, saw an increase of about $0.32. Then switching to Opus 5, did stuff, refreshed, increased by $2.56. So it was good for me to assess each individual model cost/performance.”

That’s the real use case: helping engineers answer “is this model worth it for this task?”

That use case is gone.

What happened simultaneously: 30x token consumption variance

At the same moment this story broke, a HN commenter named @tosh posted a benchmark table. He ran 10 agentic tasks using the same model (GPT 5.6 Sol) inside an Ubuntu 26.04 VM, and measured token usage across different harnesses:

Harness       | Total tokens used
--------------+-------------------
smol          |        172,807
Pi            |        427,211
OpenCode      |      1,564,429
Codex         |      3,005,744
Hermes        |      3,856,611
Claude Code   |      5,073,137

Every harness completed the tasks. But Claude Code used 29x more tokens than smol.

What does this mean in practice? If you’re using Claude Code with Opus 5, you’re burning through plan credits roughly 29x faster than smol would for the same work. Even on a flat-rate subscription, that directly determines “how long does my monthly quota last.”

More interesting, tosh noted:

“Often the harness using fewer tokens is not only done faster but has better results.”

Fewer tokens, better results. This breaks an implicit assumption: massive context injection doesn’t always help the AI — sometimes it just confuses it.

@yojo explained why Claude Code lands at the top of the cost chart:

“Claude Code injects a ton of tools into the system prompt, including their ‘memory system’ that’s like 10k+ tokens. Depending on your task shape, this can easily double your task cost.”

So: Cursor deleted your cost visibility without notice, and at the same time, real cost differences between tools can reach 30x. Together, these two facts form a complete problem: without transparency, you have no way to know you’re paying the most expensive price for something that could be 30x cheaper.

The first move after a $6B acquisition

Cursor was acquired by SpaceX/xAI for approximately $6 billion this year. Post-acquisition, Grok 4.5 became one of Cursor’s default flagship models, with Composer 2.5 as its in-house coding model.

From HN, @jjice:

“Absolute insanity to do something as user hostile as removing the cost of the service. Gotta justify a $60B purchase of an IDE.”

Long-time Cursor user @aroman:

“I was an early and passionate adopter and paying customer of Cursor (since 2023!), but it’s probably been 6 months since I opened it. These days I ‘write’ code with Claude Code and Codex, and read/review it on GitHub.”

@sergiotapia:

“Cursor you have a beautiful comeback story… why on earth are you squandering this opportunity and behaving this way? You came back from the dead pretty much and now you’re pissing it away for what exactly?”

The dynamic is uncomfortable: a developer-facing tool, acquired by an entity with its own definition of “acceptable opacity,” selling to users who are by nature resistant to black boxes.

Developers can run curl and personally verify whether an API field was zeroed out.

This isn’t unique to Cursor

Anyone who’s managed AWS infrastructure knows what a complex bill looks like. Figuring out which line is real cost, which is reserved-instance amortization, and which is free-tier credit requires dedicated engineering time.

AI tools are following the same path:

• Replace “dollars per request” with “credits / tokens / points”
• Mix included-plan usage with actual overage charges
• Change pricing logic with every tier upgrade, making historical data meaningless as a benchmark

The commercial logic is straightforward: when users can’t perceive marginal cost, their usage isn’t constrained by cost awareness, making it easier to push them toward larger plans.

@xp84 on HN put it plainly:

“I think these companies want to make token usage opaque. Not dissimilar from an AWS bill at most orgs. I suspect they want to make it super hard to tell the difference between an engineer making wasteful decisions of how to use AI, and someone getting great ‘value per token.’”

What you can do now

First: don’t trust any AI tool’s built-in usage dashboard.

Cursor just demonstrated that built-in dashboards can retroactively modify historical records. The only reliable option is logging every API call’s prompt_tokens, completion_tokens, and timestamp in your own infrastructure — and converting to dollars yourself.

Second: actually measure token efficiency, not just “which tool feels better.”

The comparison table shows harness choice has a bigger cost impact than model choice. smol used 172k tokens; Claude Code used 5M — for the same results. Test this on your actual task shape.

Third: treat opacity as a product selection criterion.

When a tool starts systematically obscuring cost information, that’s a signal: its commercial interests have started to diverge from your engineering decision-making interests. This doesn’t mean immediately switching tools. But it should be in your head when renewal comes around.

Summary

Subscription-model AI tools have a structural conflict of interest with user cost transparency. This isn’t a moral judgment on any particular company — it’s an inherent tension in the business model. Understanding that is more useful than being angry.

🛠 Evaluating AI coding tool costs for your team?

• Does your team have token usage tracking independent of the tool itself?
• Are you using Claude Code or smol/Pi? Have you measured the difference?
• What’s your decision tree when a tool starts obscuring billing information?

📬 Follow 梦兽编程 for in-depth AI engineering tool analysis.

Sources:

• Cursor Community Forum: Usage Page $$ to Token Amount? WHAT? External link
• HN discussion: Cursor removed cost information from the usage page and CSV export External link
• @tosh benchmark data: HN comment External link · X thread External link