# Vibe Coding Tool Prices: How to Calculate Your Budget
> Claude Code pricing enterprise budgets: published per-developer usage benchmarks, subscriptions, token charges, caching, and extra costs for coding tools.
Source: https://ailoot.ai/blog/en/vibe-coding-tool-prices/
Canonical: https://ailoot.ai/blog/en/vibe-coding-tool-prices/
Language: en
Publisher: Ailoot (https://ailoot.ai/)
Translation: guide-018
Revision: sha256-9223bbf686d52cf804970114ac489b64c998f313850579af97940c6606569c07
When choosing a tool, it’s not just about which one is best. There’s another question: how much will it cost per month, and can you calculate that in advance so you don’t get blindsided?
There’s no single-number answer, and that’s the main problem with all the articles on this topic. One person pays $20 and never hits the limit; another pays the same and burns through the allowance on the first evening. They have the same plan, and the difference comes down entirely to how they work.
Below are prices for vibe coding tools from official pages as of August 19, 2026, and an analysis of what accounts for the difference. All figures are linked, and the date they were checked is given. Where a company doesn’t publish a figure, I say so instead of filling in a commonly cited number from someone else’s reviews.
Model connections and API usage are covered in the [Ailoot documentation](https://ailoot.ai/docs/).
Warning
This material is for reference and does not contain individual legal advice.
## How much should I budget for AI coding tools each month?
Key takeaway
Anthropic’s own benchmark for enterprise deployments is $150 to $250 per person per month, with nine out of ten users’ spending staying below $30 per working day. For a solo builder putting together their own product in the evenings, the range is wider and starts with a single $20 subscription.
The only official figure you can rely on is in the Claude Code documentation. It’s for teams, but it gives you a sense of scale.
Enterprise deployments average around $13 per developer per active day and $150 to $250 per month, with 90% of users’ spending staying below $30 per active day.
— Anthropic, https://code.claude.com/docs/en/costs
The picture is different for an entrepreneur building a single product. Here are three typical work patterns and their monthly costs.
| Work pattern | What you get | Monthly cost |
|----|----|----|
| Trying it out in the evenings, one project | one entry-level subscription | $18-20 |
| Building my own product, working almost every day | mid-tier subscription plus a backup tool | $100-120 |
| Multiple projects, parallel agents | two top-tier subscriptions or a subscription plus pay-as-you-go usage | $200-300 |
The top row isn’t a ceiling. The bottom row, meanwhile, is realistic. One $20 subscription is enough to get a first project to a working state, and that’s exactly where I recommend starting.
## Claude Code pricing tokens: what are input, output, and cache charges? {#what-exactly-are-you-paying-for}
Key takeaway
The cost breaks down into three parts. First is the application shell itself, which is often free. Second is the model that does the thinking, and that’s what you always pay for. Third is the platform where the project lives after publication. Confusion starts when someone thinks they’re paying for the application.
The shell is what runs on your machine: a terminal window, an editor extension, or a standalone application. Cline, Aider, and OpenCode are completely free and open source. Zed’s entry-level tier is also free and explicitly offers the option to use your own keys.
Unlimited usage with your own API keys or external agents like Claude Agent, Codex CLI, and others.
— Zed, https://zed.dev/pricing
The model is what actually costs money. Usage is measured in tokens: a token is a small piece of text, roughly three or four Russian letters, and tokens measure everything you send to the model and everything it sends back. That leaves two payment methods: a fixed subscription with a limit, or a bill based on each million tokens processed.
The same Claude Code works either way, and the final amount can differ by dozens of times. I wrote about where to check your remaining subscription allowance in my breakdown of [Claude Pro and Max limits](https://ailoot.ai/blog/en/claude-pro-max-usage-limits/).
The platform—hosting, domain, database—runs separately and is billed under its own rules. It’s usually excluded from calculations of vibe coding tool prices, even though it adds to the bill. If you can build a product so you don’t have to pay for someone else’s subscription every month, that’s a separate discussion: [how to build your own service instead of an expensive subscription](https://ailoot.ai/blog/en/own-service-instead-of-claude-code-subscription/).
## Claude Code pricing vs GitHub Copilot: how much do subscriptions cost in 2026? {#how-much-do-subscriptions-cost-in-2026}
Key takeaway
The entry-level paid tier costs $8 to $20 for almost everyone, the mid-tier $39 to $100, and the top tier $100 to $200. Nearly every service has a free tier, but it’s intended for trying things out: it isn’t enough for regular work. All prices below were taken from official pages on August 19, 2026.
| Tool | Free | Entry-level paid | Mid-tier | Top tier |
|----|----|----|----|----|
| Claude (includes Claude Code) | yes | Pro $20 (or $17 with annual billing) | Max 5x $100 | Max 20x $200 |
| Codex by OpenAI | yes | Go $8, Plus $20 | \- | Pro from $100 |
| Cursor | Hobby $0 | Pro $20 | Pro+ $60 | Ultra $200 |
| GitHub Copilot | 2,000 completions per month | Pro $10 | Pro+ $39 | Max $100 |
| Devin (Windsurf has moved here too) | yes | Pro $20 | \- | Max $200 |
| GLM Coding Plan by Z.ai | \- | Lite $18 (or $12.6 with annual billing) | Pro $80 | Max $168 |
| Kimi by Moonshot | \- | $19 | $39 | $99 and $199 |
| Google Antigravity | $0 for individuals | \- | \- | \- |
| Replit | Starter $0 | Core $25 | Pro $100 | \- |
| Lovable | 5 credits per day | Pro from $25 | \- | \- |
| Zed | Personal $0 | Pro $10 | \- | Business $30 per seat |
Three things in this table upend what people were writing about vibe coding tool prices just a year ago.
**Windsurf no longer exists as a separate product.** windsurf.com now redirects to devin.ai, and the pricing plans have moved there too. If you’re reading an article that compares Windsurf by its own pricing structure, it’s out of date. The comparison of [Windsurf and Claude Code](https://ailoot.ai/blog/en/windsurf-vs-claude-code/) shows what remains of the product.
**Roo Code has shut down.** The project repository says outright that the extension was disabled on May 15. The authors suggest moving to [Cline, which Roo Code originally grew out of](https://ailoot.ai/blog/en/cline-vs-claude-code/).
**Continue is no longer supported.** The repository has been marked by its author as abandoned, although it still appears in lists of free shells.
A separate note about Claude’s top tier, because it’s constantly misrepresented in both directions. Anthropic’s pricing page says only “from $100 per month,” without a breakdown, so you can’t get the figure from that page alone. The full numbers are in the help article about the Max plan: five times the volume costs $100 per month, and twenty times costs $200.
## Gemini API pricing and other model rates: what does pay-per-token usage cost? {#how-much-does-pay-per-token-pricing-cost}
Key takeaway
A million input tokens costs from 10 cents for the lightest models to $10 for the heaviest. The output/input price ratio depends on the model: divide the output rate by the input rate in that model’s row. The spread between the high and low ends is a hundredfold, making it possible to save by choosing a model to fit the task.
| Model | Per million input tokens | Per million output tokens |
|------------------------------|----------------------|---------------|
| Claude Opus 5.5 | $4 | $20 |
| Claude Opus 5 | $5 | $25 |
| Claude Sonnet 5 | $2 | $10 |
| Claude Haiku 4.5 | $1 | $5 |
| Claude Fable 5 | $10 | $50 |
| gpt-5.6-sol | $5 | $30 |
| gpt-5.6-terra | $2 | $12 |
| gpt-5.6-luna | $0.20 | $1.20 |
| qwen3-coder-plus | $1 | $5 |
| qwen3-coder-flash | $0.30 | $1.50 |
| kimi-k2.7-code | $0.95 | $4 |
| deepseek-v4-pro (off-peak) | $0.66 | $1.98 |
| deepseek-v4-flash (off-peak) | $0.22 | $0.66 |
| Gemini 2.5 Flash | $0.30 | $2.50 |
| Gemini 2.5 Flash-Lite | $0.10 | $0.40 |
A caveat about the table: OpenAI and Alibaba’s rates are for the shortest input-length tier. When very long text is sent to a model, their rates rise two- to threefold, which is noticeable on large projects.
The Opus 5.5 row was added on September 22, 2026, and changes the usual math in the reader’s favor. The flagship Claude model became cheaper for the first time: $4 and $20 instead of Opus 5’s $5 and $25, a 20% reduction in token prices. Cache reads cost $0.20 per million instead of $0.50—a 60% drop—and cache reads account for most of the bill when working with code. Anthropic estimates total savings of 40% on a typical workload with default settings. If you calculated your budget using Opus 5 rates, recalculate: the same work now costs noticeably less.
Calculate the multipliers from the selected row rather than using a universal rule. In this table, output/input is 20/4 = 5× for Opus 5.5, 30/5 = 6× for gpt-5.6-sol, 1.98/0.66 = 3× for DeepSeek V4-Pro, and 2.50/0.30 ≈ 8.33× for Gemini 2.5 Flash. The stated Opus 5.5 cache-read rate gives 0.20/4 = 0.05: a cache read costs 5% of ordinary input, or one-twentieth, while Opus 5 gives 0.50/5 = 0.10, or one-tenth.
For a metered estimate, calculate `(uncached input × input rate + cached input × cache-read rate + output × output rate) / 1,000,000`; add cache-write charges and other billable items separately where applicable. Use observed cache-hit tokens, not all repeated text. Batch discounts must be checked for the selected model and service rather than inferred from the cache ratio.
DeepSeek has its own pricing model, tied to the time of day.
Off-peak rates are half the peak rates. Peak hours are 01:00 to 04:00 and 06:00 to 10:00 UTC; all other hours are considered off-peak.
— DeepSeek, https://api-docs.deepseek.com/quick_start/pricing
If your working hours fall within the off-peak intervals in UTC, the off-peak rate applies, meaning half price. I covered the pitfalls of paying separately: [how to pay for the DeepSeek API](https://ailoot.ai/blog/en/deepseek-api-payment/). The open model from Zhipu uses similar pricing math; its comparison with Claude is in the [GLM-5.2](https://ailoot.ai/blog/en/glm-5-2-vs-claude-code/) breakdown.
## Which is better value: a subscription or pay-as-you-go?
Key takeaway
The break-even point is around $200 per month. Below that, pay-per-token is usually cheaper than a subscription and more flexible. Above it, subscriptions win by a wide margin:. Repeatedly reading context is what makes the difference in this math.
What makes the difference is caching: text already sent to the model isn’t recalculated from scratch. Until the cache expires, the model reads it at a discounted rate.
Here’s how I see the choice. Comparing a subscription with pay-per-token is pointless until you know whether your cache persists between requests: the same amount of work costs very different amounts depending on how you handle context. Measure first, then choose a plan.
The final amount is determined by what goes into the model and how much; the rate barely matters by comparison. Context engineering is about giving the model what it needs without making it carry unnecessary context.
## Why does a subscription run out in a day?
Key takeaway
There’s almost always one reason: every request carries the entire conversation with it. A one-line question in a session opened in the morning is billed as the whole day’s conversation. Here are six habits I see most often, each making the model reread the full history from scratch at the regular rate.
The mechanism is stated plainly in the Claude Code documentation: the application sends the entire conversation with each request, and every time the model calls a tool, another request is sent with the accumulated result.
These six habits burn through your allowance fastest. The list is mine, but each item is based on official documentation.
1. **A break longer than an hour.** The subscription cache lasts one hour. Step away for lunch, come back, ask a question, and you pay to reread the entire history. On purchased usage, the cache lifetime drops to five minutes; that’s also the default behavior for API keys and cloud platforms.
2. **Switching models midway through a task.** Each model has its own cache. Switch using `/model`, and the next request reads the entire history without a single cache hit, even though not one character of the text has changed.
3. **Parallel agents.** A team of agents uses roughly seven times more tokens than a regular session because each collaborator has its own context window.
4. **Connecting and disconnecting extensions mid-session.** Tool descriptions are stored in the system part of the request, and as soon as the set changes between turns, the cache is fully reset.
5. **A large model for a small task.** Anthropic lists this alongside open sessions as the leading cause of unexpectedly high bills.
6. **Vague requests.** “Improve the project” triggers a full scan.
The Claude Code team itself confirms this.
Cache misses with a million-token context window are expensive. Claude Code keeps a one-hour cache window for the main agent, so if you step away from the computer for more than an hour and continue an old session, it’s often a complete cache miss.
— Claude Code team (Anthropic)
I’ve collected eight rules to prevent this separately: [how not to burn through Claude Code limits in a day](https://ailoot.ai/blog/en/claude-code-token-limits-saving/).
## How do limits work, and when do they reset?
Key takeaway
Claude has two windows: a rolling five-hour one and a weekly one with a reset time fixed for the account. Cursor counts directly in dollars, using two separate pools. Since June 1, 2026, GitHub Copilot has used credits, where one credit equals one cent. Anthropic doesn’t publish token-based limit amounts anywhere.
Anthropic describes the mechanics but doesn’t provide numbers. The session limit resets every five hours; the weekly limit resets at a time fixed for the account, the same from one week to the next no matter when you started working.
There are two weekly counters: a separate one for Opus and a shared one for the other models. Usage counts across all product surfaces—web, desktop app, and Claude Code all draw from the same limit. Switching models doesn’t restore access because the windows are shared.
With the release of Opus 5.5 on September 22, 2026, Anthropic increased the five-hour limits on Pro, Max, Team, and seat-based Enterprise plans. The company still doesn’t publish specific numbers, so you’ll still have to check the counter in your account to see what’s left. Subscribers also received a one-time limit reset that they can save for a convenient time.
Cursor’s logic is different: included usage is measured in dollars for third-party models. Pro at $20 includes $20 in usage; Pro+ at $60 includes $70; Ultra at $200 includes $400. When that runs out, work continues at the regular pay-as-you-go rates, and the company separately states that requests aren’t slowed down or reduced in quality. The [Cursor and Claude Code](https://ailoot.ai/blog/en/cursor-vs-claude-code/) comparison shows how the tools differ in other respects.
GitHub Copilot moved to credits on June 1, 2026. The old premium request system remains only for some annual subscribers and is marked as deprecated in the documentation.
| Copilot plan | Price | Base credits | Flexible allotment | Total |
|--------------|-------|-----------------|----------------|--------|
| Pro | $10 | 1,000 | 500 | 1,500 |
| Pro+ | $39 | 3,900 | 3,100 | 7,000 |
| Max | $100 | 10,000 | 10,000 | 20,000 |
One credit equals one cent, so Pro at $10 provides $15 worth of usage. Code completions and next-edit suggestions don’t use credits at all and are unlimited on paid plans.
The overall story over the past year: all three major companies moved from fixed units to metered billing. Any article older than June 2026 that mentions “300 premium requests per month” describes a system that no longer exists.
## What extra charges are hidden behind a subscription?
Key takeaway
A subscription covers the limit, but not everything. Claude Code’s fast mode isn’t included at all and is billed only against purchased usage. Cursor charges its own rate on top of the model price on team plans. Purchased API usage expires after a year and isn’t refunded.
| Where | Extra charge for | How much |
|----|----|----|
| Claude Code | fast mode, not included in the subscription | For Opus 5.5: $8 per million input tokens and $40 per million output tokens; for Opus 5 and Opus 4.8: $10 and $50 |
| Claude Code | first activation of fast mode in a conversation bills all accumulated context at the higher rate | depends on conversation length |
| Claude Code | background usage in an open, idle session | usually less than $0.04 per session |
| Claude, API | purchased usage expires after a year and isn’t refunded | \- |
| Cursor, Teams and Enterprise plans | its own charge on top of the model price for requests to third-party models | $0.25 per million tokens |
| GitHub Copilot | purchasing more after credits run out | 1 credit = $0.01 |
The fast mode trap deserves a couple of words. It’s not just excluded from the subscription: the moment you turn it on mid-conversation, all the context accumulated so far is repriced at the higher rate at once. The cost of turning it on depends on how long the open conversation is. What you write afterward doesn’t affect it.
There’s a downside in the other direction too. The subscription cache lasts an hour, but when you switch to purchased usage, its lifetime drops to five minutes. Resuming work after a break gets more expensive precisely when you’re already paying over your plan.
## Service terms and resellers
Anthropic publishes a list of supported regions. The same page includes a disclaimer that the company reserves the right not to provide services. OpenAI publishes its own list with a direct warning: accessing services from outside the listed countries may result in account deactivation or suspension.
GitHub’s trade controls statement says that Copilot may not be sold, exported, or re-exported to countries in group E:1.
Cursor has no country list, but its terms of service include a trade-controls clause. There’s another provision, though, that matters when buying access through intermediaries.
Cursor subscriptions are sold only directly through cursor.com. We don’t authorize any resellers or third-party sellers. Subscriptions bought from any other source are unauthorized and may be fraudulent.
— Cursor, https://cursor.com/pricing
Everything listed above was published by the companies themselves and can be verified using the links at the end of the article. I’m presenting these as facts to know before paying, and I’ll stop there: there are no workarounds, reseller names, or ways to pretend to be a resident of another country here. Everyone decides for themselves and is responsible for their own decision.
## What set of tools should you assemble for your budget?
Key takeaway
Three workable setups: one paid subscription plus free shells; Claude’s mid-tier as the main tool; or two top-tier subscriptions for parallel work. Below is what each includes and what you knowingly give up.
**Setup one, entry-level paid tier.** One entry-level subscription: Claude Pro for $20, Codex Plus for the same $20, or GLM Coding Lite for $18. Add free tools: Google Antigravity for individuals, Zed’s entry-level tier, or Cline or Aider as shells for your own keys. If you’re installing Claude Code for the first time, start with [this separate guide](https://ailoot.ai/blog/en/install-claude-code/).
What you give up: parallel work and heavy models. The limit is enough for one project and an evening’s work, but it runs out during long sessions. That’s enough to find out whether this way of working is for you.
**Setup two, mid-tier.** Claude Max 5x for $100 as your main tool, with everything else free around it. A cheaper alternative is Claude Pro for $20 plus GLM Coding Lite for $18 as a second subscription for when the first hits its limit. Open models handle a significant share of tasks; I’ve collected what they can do in my review of [free coding models](https://ailoot.ai/blog/en/free-coding-models/).
What you give up: almost nothing if you work alone and sequentially. This is the practical choice for someone building their own product every day.
**Setup three, two top-tier subscriptions.** Two top-tier subscriptions: Claude Max at $100 or $200 plus Codex Pro starting at $100. The point is continuity: hit one provider’s weekly window, switch to the other, and don’t lose a working day. What Codex is and how to install it are covered in [a separate guide](https://ailoot.ai/blog/en/openai-codex-install/).
What you give up: money, in exchange for continuity. This setup makes sense when downtime costs more than a subscription—in other words, when customers are already relying on your product.
None of these setups include pay-as-you-go usage beyond the limit. It’s rarely needed, and relying on it as a habit drives up the bill faster than anything else. The full task-based tool breakdown, regardless of price, is in the [Claude Code alternatives](https://ailoot.ai/blog/en/claude-code-alternatives/) collection and the [what to code with in 2026](https://ailoot.ai/blog/en/ai-coding-tools/) review.
## How can you estimate the monthly cost in advance?
If the billing currency differs from your account currency, check your bank’s exchange rate and payment fee: the bank sets these terms, and the service has no control over them. When calculating your monthly budget, leave room for possible exchange-rate differences and fees.
Key takeaway
Calculate based on your own spending for a week. The process is: work as usual with a tracker for a week, check your total usage at API rates, divide by the subscription price, and you’ll get an honest multiplier. If it’s less than one, you don’t need the subscription. You’ll have to repeat the measurement: usage grows as the project gets more complex.
1. ### Set up a usage tracker
Calculating it manually is pointless. I reviewed tools that collect usage from local session records in my article on Claude Code token trackers. For a quick check inside Claude Code, use the `/usage` command.
2. ### Work a normal week
Don’t change your habits for the measurement: a staged measurement won’t tell you anything. A week is needed because the weekly limit window is the main constraint people hit.
3. ### Record two figures
First, what your work would have cost at API rates. Second, what you actually paid for the subscription. Both figures should be for the same week.
4. ### Divide one by the other
Less than one: the subscription is too expensive for you; consider pay-as-you-go. From one to five: the difference is small, so choose based on convenience. More than five: the subscription is good value, and the higher the multiplier, the better.
5. ### Recalculate in a month
Usage grows as the project gets more complex. A measurement made in the first week will be out of date by the third month.
Warning
If you switch from a subscription to pay-as-you-go after measuring, remember the difference in what happens when you exceed your limit. A subscription hits its limit and stops, so it puts the brakes on by itself. Pay-per-token never stops: the bill keeps growing as long as you work. Set a spending limit in your account in advance, before switching.
If you want to estimate the cost before starting work, here’s a prompt that calculates it from your task description. It won’t replace measurement, but it gives you a ballpark figure.
Prompt
Prompt for estimating monthly usage
```
Count my estimated monthly spend on AI coding tools.
My details:
How many hours per week I work on the project: [FILL IN]
Approximate number of files in the project: [FILL IN]
Whether I work sequentially or launch several agents at once: [FILL IN]
Whether I take long breaks of more than an hour in the middle of work: [FILL IN]
Which model I use by default: [FILL IN]
What I need from you:
Estimate the volume of tokens per week, broken down into new text and rereading context. Explicitly state the assumptions you made.
Calculate the cost using the current rates per million tokens for the model I named. Calculate separately for a cache hit and without caching.
Compare the resulting amount with a fixed subscription and tell me which is more cost-effective for me.
Name three habits from my details that drive up costs the most, and say what to do about each.
In a separate line, say where your estimate is most likely to be wrong.
Don't round in my favor. If you don't have enough data, ask clarifying questions before calculating.
```
## What else do people ask about prices?
Key takeaway
I’ve collected the questions that come up most often: about free access, the cost differences between tools, buying more beyond the limit, and whether it’s possible to avoid paying altogether. The answers are based on official pages and don’t promise that you’ll get exactly the same results.
### Frequently asked questions
Can I work entirely for free?
Partly, yes. The Cline, Aider, and OpenCode shells are free, as is Zed’s entry-level tier; Google Antigravity is free for individuals. But the model that does the thinking is almost always paid: free tiers are meant for trying things out and run out quickly. The only completely free option is running an open model on your own hardware, which requires a graphics card.
Which tool is the cheapest?
At the entry-level paid tier, GitHub Copilot for $10 and Zed Pro for the same $10. For usage volume per dollar, it’s GLM Coding Lite at $18, which includes 10,000 credits per week and is said to work through Claude Code. But the tool with the lowest listed price and the tool with the lowest final bill are different things, because your usage affects the bill more than the plan does.
What happens when the limit runs out?
It depends on the service. Claude stops working until the window resets, and a message shows when that will happen. Cursor continues at the regular pay-as-you-go rates, with no reduction in quality or speed. GitHub Copilot code completions continue to work on paid plans after credits run out because they don’t use credits.
How much does the top Claude Max tier cost?
Five times the Pro volume costs $100 per month; twenty times costs $200. Anthropic’s main pricing page shows only the lower bound, “from $100,” while the full amounts are in the Max plan help article. That discrepancy is why figures vary across reviews.
Is it worth getting an annual subscription?
There is a discount: Claude Pro is $17 instead of $20, GLM Coding Lite is $12.6 instead of $18, and Replit Core is $20 instead of $25. But the market has been reshaped three times in the past year, with products shutting down and moving elsewhere, so a year is a long time. I’d choose annual billing only for a tool I’d already been using for several months in a row.
Why is my usage higher than my friend’s on the same plan?
Most likely, it’s the cache. The same amount of work can cost very different amounts depending on whether context is preserved between requests or reread from scratch. Breaks longer than an hour, switching models mid-task, and parallel agents are the three main sources of this difference.
Can I buy a subscription from a reseller?
Cursor explicitly says that subscriptions are sold only through its website and the company doesn’t authorize resellers. It describes purchases from other sources as unauthorized and potentially fraudulent. I couldn’t find the same direct wording from other companies, but the risk is the same everywhere: you’re buying access from someone who isn’t a party to the agreement.
## Where to start
Key takeaway
The process is simple: start with one entry-level subscription and a week of normal work with a tracker, then measure, and only then decide on a plan. There’s no reason to start at the top tier: without measuring, you don’t know what limit you’ll hit, and you’re almost certain to overpay. The biggest savings, meanwhile, don’t come from the plan at all.
Here are the three steps I recommend, in this order.
First, get one $20 subscription and nothing else. One paid account is enough to figure out whether this way of working suits you.
Second, work as usual for a week with a usage tracker, without deliberately economizing or ramping things up. Otherwise, the measurement will be useless.
Third, look at the two figures and decide. If you hit the limit on the third day, consider a mid-tier plan. If you never hit it, stay where you are and invest the difference in something that makes money.
Finally, here’s something that rarely makes it into articles about vibe coding tool prices. The biggest savings come from disciplined context management, and the plan is secondary: the difference between careful and careless work is measured in multiples, while the difference between plans is measured in tens of percent. I covered why spending is almost always higher than expected in the article on [why vibe coding costs more than it seems](https://ailoot.ai/blog/en/vibe-coding-cost-time/). And if your card is declined during payment, the reasons are covered in the guide on [how to pay for Claude Code](https://ailoot.ai/blog/en/claude-code-plans-cost/) and the article on [renewing a subscription](https://ailoot.ai/blog/en/claude-subscription-renewal-cancellation/).
### Sources
- [Claude - pricing page](https://claude.com/pricing)
- [Anthropic - what the Max plan is, tier prices, and limit resets](https://support.claude.com/en/articles/11049741-what-is-the-max-plan)
- [Claude Code - managing usage and why bills grow](https://code.claude.com/docs/en/costs)
- [Claude Code - how prompt caching works](https://code.claude.com/docs/en/prompt-caching)
- [Claude Code - fast mode and its pricing](https://code.claude.com/docs/en/fast-mode)
- [Anthropic - API pricing by model](https://platform.claude.com/docs/en/about-claude/pricing)
- [Anthropic - announcement of Claude Opus 5.5 and price reduction](https://www.anthropic.com/news/claude-opus-5-5)
- [Anthropic - list of supported regions](https://www.anthropic.com/supported-countries)
- [Anthropic - how limits work and what the counters show](https://support.claude.com/en/articles/9797557-usage-limit-best-practices)
- [Cursor - pricing page and reseller policy](https://cursor.com/pricing)
- [Cursor - included usage and charges beyond it](https://cursor.com/docs/account/pricing)
- [GitHub Copilot - plans and pricing](https://github.com/features/copilot/plans)
- [GitHub Copilot - move to credits and flexible allotment](https://github.blog/news-insights/company-news/github-copilot-individual-plans-introducing-flex-allotments-in-pro-and-pro-and-a-new-max-plan/)
- [GitHub - trade controls and country list](https://docs.github.com/en/site-policy/other-site-policies/github-and-trade-controls)
- [Codex and ChatGPT - pricing](https://learn.chatgpt.com/docs/pricing)
- [OpenAI - API pricing by model](https://developers.openai.com/api/docs/pricing)
- [OpenAI - list of supported countries](https://developers.openai.com/api/docs/supported-countries)
- [Devin - pricing, where Windsurf also moved](https://devin.ai/pricing)
- [Google Antigravity - pricing](https://antigravity.google/pricing)
- [Z.ai - GLM Coding Plan subscription](https://z.ai/subscribe)
- [Kimi by Moonshot - pricing](https://kimi.ai/resources/kimi-k2-7-code-pricing)
- [DeepSeek - pricing and peak hours](https://api-docs.deepseek.com/quick_start/pricing)
- [Alibaba Cloud Model Studio - Qwen model pricing](https://www.alibabacloud.com/help/en/model-studio/model-pricing)
- [Google - Gemini API pricing](https://ai.google.dev/gemini-api/docs/pricing)
- [Zed - pricing](https://zed.dev/pricing)
- [Replit - pricing](https://replit.com/pricing)
- [Lovable - pricing and credits](https://docs.lovable.dev/introduction/subscription-plans)
- [Roo Code - announcement of extension shutdown and successors](https://github.com/RooCodeInc/Roo-Code)
- [Continue - repository marked as unsupported](https://github.com/continuedev/continue)
You can continue working with AI in [Ailoot](https://ailoot.ai/).
## Questions about Vibe Coding Tool Prices: How to Calculate Your Budget
### How do I calculate a model’s output-price multiplier?
Divide its output rate by its input rate. The table gives 6× for gpt-5.6-sol, 3× for DeepSeek V4-Pro, and about 8.33× for Gemini 2.5 Flash; there is no universal 4–5× multiplier.
### Can I price every repeated input token as a cache hit?
No. Use the actual cached-input count and that model’s cache-read rate, then add uncached input, output, and any cache-write charges separately. For the stated Opus 5.5 rates, 0.20/4 is 5%, not 10%.
## Ailoot · The company and its project portfolio
Ailoot combines established operating experience, a large client base, stable service and ongoing KPI control.
The company and its project portfolio: millions of customers; monthly sales in the billions.
Ailoot brings that operating experience to API access for AI features in customer products, agents, applications and automations.