Prices verified against vendor documentation on 13 August 2026. Sources: Anthropic's plan pricing, GitHub's Copilot plans and billing docs, OpenAI's ChatGPT pricing, and Google's Gemini CLI quota documentation. Two things changed materially in 2026 and are still reported incorrectly almost everywhere: GitHub retired per-request "premium request" billing in favour of GitHub AI Credits, and OpenAI added an $8/month ChatGPT Go tier that includes Codex. If a comparison you are reading still quotes "$0.04 per premium request" or "300 premium requests," it has not been updated this year.
The entry points now run $0 (Gemini CLI, and Codex on ChatGPT Free), $8 (ChatGPT Go), $10 (GitHub Copilot Pro), and $20 (Claude Pro or ChatGPT Plus). The ceilings are $39/month for Copilot Pro+, $100/month and up for Claude Max, and $100/month and up for ChatGPT Pro. For most working developers the best value is not the highest tier of one tool but a mix: a paid primary CLI for complex, multi-file work plus Gemini's free tier for research and large-codebase reads. The single biggest hidden cost is not the subscription — it is hitting a usage limit mid-task, which can cost more in lost focus than any upgrade.
That is the summary an AI overview would hand you. What it cannot show you is how those numbers interact with your actual workflow — which limit you will hit first, whether a hard stop or a metered overage fits your budgeting style, and which two-tool combination costs the least for your usage pattern. Below is an animated decision flow to route you to the right tool, a copy-ready selection checklist, and a full deep-dive on each tool's pricing, limits, and overage behavior.
This guide breaks down the complete pricing landscape for the four major AI coding CLI tools: Claude Code, Gemini CLI, OpenAI Codex CLI, and GitHub Copilot CLI.
Which AI Coding CLI Should You Pay For?
The fastest way to a decision is to start from your hardest constraint -- budget, primary task, or team management -- and follow it to a recommended tool. This flow encodes the same logic used in the recommendations further down.
Tool-selection checklist
Work down this list before you enter a card number. Each item routes to a section below.
- Do I have a Google account? If yes, install Gemini CLI first -- its free tier costs nothing and handles research, docs lookups, and large-codebase reads (1M-token context).
- What is my hardest single constraint -- money, uninterrupted flow, or team management? Start the flow above from that box.
- Which limit will I hit first? Estimate daily message volume; a hard stop (Claude) vs. a metered overage (Copilot's $0.04/request) is a budgeting-style choice, not just a price.
- Do I need an API-only, pay-as-you-go path? Only Claude Code (Anthropic API key) and Gemini (Vertex AI) offer one; Codex CLI requires a ChatGPT subscription.
- Do I need image input (screenshot/mockup to code)? That points to Codex CLI.
- Do I need GitHub-native workflow automation? That points to Copilot CLI.
- Do I need SSO/SAML, audit logs, or IP indemnity? That means a Business/Enterprise tier, not an Individual plan.
- Have I paired a paid primary with the free Gemini tier so I stop spending premium tokens on cheap tasks?
Quick Pricing Comparison
Here is the side-by-side, all four tools, as documented on 13 August 2026:
| Tool | Free tier | Entry paid | Mid tier | Top individual tier | Team / Enterprise |
|---|---|---|---|---|---|
| Claude Code | No | $20/mo (Pro; $17 annual) | — | $100/mo+ (Max, 5x or 20x) | Team $25/seat/mo ($20 annual); Enterprise $20/seat + usage |
| Gemini CLI | Yes — 60 req/min, 1,000 req/day | API key (pay per token) | Code Assist Standard (1,500 req/day) | — | Code Assist Enterprise (2,000 req/day) |
| Codex CLI | Yes (ChatGPT Free) | $8/mo (Go) | $20/mo (Plus) | $100/mo+ (Pro, 5x or 20x) | Business $25/user/mo ($20 annual); Enterprise custom |
| Copilot CLI | Yes (Copilot Free) | $10/mo (Pro) | — | $39/mo (Pro+) | Business $19/user/mo; Enterprise $39/user/mo |
Key takeaway: the "only Gemini is free" framing that dominated 2025 coverage is out of date — Codex and Copilot both have free tiers now, and ChatGPT Go undercuts every other paid plan at $8/month. Gemini CLI still has by far the most generous free allowance for actual daily work.
One nuance the table cannot capture: these tiers are not priced on the same unit. Claude and ChatGPT sell usage windows, Gemini sells request counts, and Copilot sells credits denominated in dollars. That is why the sections below matter more than the sticker prices — a $10 plan with metered overage and a $20 plan with a hard stop are different products, not just different prices.
Claude Code Pricing Deep Dive
Claude Code is Anthropic's agentic coding tool that runs in your terminal. It requires either a Claude subscription or an Anthropic API account.
Subscription Options
Claude Code is not sold as a separate product — it ships with every paid Claude plan, so the pricing question is really "which Claude plan."
| Plan | Monthly billing | Annual billing | Usage |
|---|---|---|---|
| Free | $0 | $0 | Limited; not practical for Claude Code |
| Pro | $20/mo | $17/mo | The standard individual tier |
| Max | From $100/mo | — | Choose 5x or 20x Pro's usage |
| Team (standard seat) | $25/user/mo | $20/user/mo | More than Pro |
| Team (premium seat) | $125/user/mo | $100/user/mo | Additional capacity |
| Enterprise | $20/seat + usage | — | Scales with model and task |
Two details that trip people up. First, Max is a price floor, not a price: Anthropic's pricing page lists Max as "from $100/month" with a selector for 5x or 20x Pro usage, so the 20x option costs more than the headline figure — check the selector before assuming $100 buys the top tier. Second, the annual discount on Pro is real but modest: $17 versus $20 saves $36 a year, which is not enough to justify an annual commitment if you are still deciding between tools.
Usage Limits and Resets
Anthropic does not publish a fixed message count per plan, and any guide that gives you one ("approximately 45 long messages per day") is quoting a number the vendor has never committed to. What is documented is the shape of the system: usage is metered against rolling windows, Max is sold explicitly as 5x or 20x Pro, and what you consume depends on the model, the context length, and the response length.
The practical consequence for Claude Code specifically: long agentic runs on a large codebase burn through a window far faster than interactive chat does, because every tool call re-sends context. If you are hitting limits, the first lever is usually reducing what you load into context, not upgrading the plan.
API Alternative: Pay-As-You-Go
If your usage is spiky or you need per-project cost attribution, Claude Code also runs against a standalone Anthropic API key at published per-token rates:
| Model | Input (per 1M tokens) | Output (per 1M tokens) |
|---|---|---|
| Claude Opus 5 | $5.00 | $25.00 |
| Claude Sonnet 5 | $3.00 | $15.00 |
| Claude Haiku 4.5 | $1.00 | $5.00 |
When to use API billing:
- Usage varies wildly month to month
- You need to track costs per project or client
- You want no ceiling at all, and are willing to accept no ceiling on the bill either
The tradeoff is direction of risk. A subscription caps your spend and rations your usage; the API caps your usage at nothing and rations nothing, including the invoice. For a solo developer, the subscription is almost always the better deal — the API only wins when usage is genuinely intermittent.
When to Upgrade from Pro to Max
Consider upgrading if you:
- Regularly exhaust your window before finishing a working session
- Run long autonomous tasks across large codebases
- Bill clients for AI-assisted development time
At $80/month more, Max pays for itself if limits cost you a little over an hour of billable time monthly. If they cost you fifteen minutes, it does not — and prompt discipline is cheaper than a plan upgrade.
For installation and setup details, see our guide on how to install Claude Code CLI.
Gemini CLI Pricing Deep Dive
Gemini CLI still has the most generous free tier of any AI coding CLI, and it is the reason the "pair a paid primary with free Gemini" strategy works.
Free Tier Details
Authenticate with a personal Google account and Google's own quota documentation grants:
- 60 model requests per minute
- 1,000 model requests per day
- Context window: 1 million tokens
- No credit card, no trial expiry
That 1,000/day figure is the number worth internalising. It is not a teaser allowance — for research, documentation lookups, and reading across a large repository, 1,000 requests is more than most developers use in a day of heavy work.
What Free Gets You
The free tier is not a crippled demo:
- Google Search grounding for up-to-date information
- Built-in tools: file operations, shell commands, web fetching
- MCP (Model Context Protocol) server support
- The full 1M-token context window
Paid Tiers: Code Assist Standard and Enterprise
Paying for Gemini CLI buys you quota, not capability. Google's documented per-user limits:
| Tier | Requests/minute | Requests/day |
|---|---|---|
| Free (Google account) | 60 | 1,000 |
| Code Assist Standard | 120 | 1,500 |
| Code Assist Enterprise | 120 | 2,000 |
Google does not publish Standard and Enterprise seat pricing on the quota documentation page; it is quoted through Google Cloud, and organisations should price it there rather than trust a third-party figure. Note how modest the jump is — Enterprise buys twice the per-minute rate and twice the daily allowance of the free tier, which tells you the paid tiers are sold for the compliance, SLA, and billing controls rather than the raw headroom.
The API Key Alternative
You can also point Gemini CLI at an API key and pay per token, which removes the request-count ceiling entirely and bills on usage instead. Because Google's per-token rates change and vary by model, price this against Google's current pricing page rather than a figure quoted in a blog post — including this one.
The general shape holds regardless of the exact rate: Gemini's cheapest models are inexpensive enough that a solo developer's coding usage typically lands in single-digit dollars per month. That is a rounding error next to a $20 subscription, which is exactly why free-tier Gemini plus one paid primary is the highest-value combination in this comparison.
For setup instructions, see our guide on how to install Google Gemini CLI.
OpenAI Codex CLI Pricing Deep Dive
Codex CLI is bundled with ChatGPT plans, and OpenAI's plan lineup expanded in 2026 — the old "you need at least Plus" advice no longer holds.
The Plan Lineup
| Plan | Price | Notes |
|---|---|---|
| Free | $0 | Includes Codex, with the tightest allowances |
| Go | $8/mo | The cheapest paid access to any CLI in this comparison |
| Plus | $20/mo | The standard individual tier |
| Pro | From $100/mo | Sold in 5x and 20x usage variants |
| Business | $20/user/mo annual, $25/user/mo monthly | 2+ users |
| Enterprise / Edu | Contact sales | — |
| API key | Usage-based | Documented as a separate path |
The $8 Go tier is the single most under-reported price in this category. If you want an agentic coding CLI and cost is the binding constraint, it is now the floor — and it did not exist when most of the comparison articles ranking for these queries were written.
How Codex Usage Limits Actually Work
Codex does not use a premium-request counter. OpenAI documents a rolling five-hour window shared between local messages and cloud chats, with additional weekly limits layered on top. Allowances within that window vary by both plan and model — larger reasoning models consume your window far faster than lighter ones, with published ranges spanning an order of magnitude between the two.
Three consequences worth planning around:
- The window is shared. Running Codex locally and kicking off cloud tasks draw from the same pool, so a heavy local session shrinks your cloud budget and vice versa.
- Model choice is the main cost lever. Dropping to a lighter model for routine edits stretches the same window dramatically. This is the highest-leverage habit on any Codex plan.
- Weekly limits sit above the five-hour one. You can pace yourself perfectly within each window and still hit a wall late in the week.
Overage and Credits
Plus and Pro users can purchase additional credits to keep working after exhausting their allowance, which softens the hard-stop problem considerably compared with waiting out a reset. Free and Go users wait for the window.
For installation details, see our guide on how to install OpenAI Codex CLI.
GitHub Copilot CLI Pricing Deep Dive
GitHub Copilot CLI is included with any Copilot subscription — no separate purchase required. Both the plan names and the billing model changed in 2026, so this is the section most likely to contradict what you have read elsewhere.
The Plan Lineup
| Plan | Price | Monthly AI Credits |
|---|---|---|
| Free | $0 | An allowance is included |
| Pro | $10/user/mo | 1,500 (1,000 base + 500 flex) |
| Pro+ | $39/user/mo | 7,000 (3,900 base + 3,100 flex) |
| Business | $19/user/mo | Organisation-managed |
| Enterprise | $39/user/mo | Organisation-managed |
Note two corrections against the figures still circulating. The "Individual" plan is now called Pro and costs $10. And Business is $19 per user per month, not $39 — that is Enterprise. Getting that one wrong doubles a team's budget estimate, so it is worth checking against GitHub's own plan documentation before you take a number to a finance conversation.
GitHub AI Credits: What Replaced Premium Requests
This is the structural change. Copilot used to bill advanced model usage in premium requests — a flat counter where the default model cost one request per interaction and heavier models cost several, with overage at $0.04 per request. That system is gone.
The replacement is GitHub AI Credits, where 1 credit = $0.01 USD. Credit consumption depends on two things: the model you select, and the tokens you actually consume — input, output, and cached. It is metered usage, not a request counter.
Why this matters more than it sounds:
- Cheap interactions got cheaper. A short completion that used to burn a whole premium request now costs a fraction of a credit.
- Expensive interactions got more expensive. A long agentic session with a large context on a frontier model can consume many credits where it previously consumed one request. If your workflow is "load the whole repo and let it run," your effective cost went up.
- Budgeting became legible. Because credits are denominated in cents, your allowance converts directly to dollars: Pro's 1,500 credits is $15 of usage bundled into a $10 plan, and Pro+'s 7,000 credits is $70 of usage in a $39 plan. Both plans include more usage value than they cost, which is the tell that GitHub is pricing for adoption.
- Flex allotments are part of the allowance. Pro's headline 1,500 is 1,000 base plus a 500 flex allotment; Pro+'s 7,000 is 3,900 plus 3,100. Check how your organisation's plan treats flex before you assume the full number is available every month.
Cost optimization tip: under credit billing, the lever is no longer "avoid the expensive models" but "avoid sending them large contexts." Model choice and context size multiply together.
Enterprise Considerations
For large organizations, Copilot Enterprise ($39/user/month) adds custom knowledge bases from your repositories, organisation-wide policy controls, SSO/SAML, audit logs, and IP indemnity. Business ($19/user/month) covers the management and policy layer without the knowledge-base features — for most teams that is the right tier, and the $20/user/month difference across fifty seats is $12,000 a year.
For setup instructions, see our guide on how to install GitHub Copilot CLI.
Hidden Costs and Considerations
Raw subscription prices do not tell the whole story. Consider these often-overlooked factors:
Overage Charges
| Tool | Overage Handling |
|---|---|
| Claude Code | Hard stop at the limit; wait for the window to reset, or upgrade |
| Gemini CLI | Free tier throttles at 60/min or 1,000/day; API key is pay-per-token with no request ceiling |
| Codex CLI | Stops at the five-hour or weekly limit; Plus and Pro can buy additional credits to continue |
| Copilot CLI | Draws down AI Credits, then usage-based billing at $0.01 per credit |
Risk assessment: Copilot's credit model gives the most predictable budgeting, because the unit is denominated in cents and overage is metered rather than blocking. Codex sits in the middle — a hard stop, but a purchasable way past it. Claude Code is the strictest: when the window is exhausted, the only options are wait or upgrade. Whether that is a flaw depends on your temperament. A hard stop caps your spend by construction; metered overage caps nothing.
Rate Limit Impact on Productivity
Hitting rate limits mid-task is more expensive than it appears:
- Context loss: Resuming after a limit requires re-explaining the task
- Flow interruption: Studies show 15-23 minutes to regain focus after interruption
- Project delays: Hard stops can push deadlines
If you earn $75/hour and rate limits cost you 30 minutes per day, that is $750/month in lost productivity---far more than any subscription upgrade.
Time Cost of Tool Switching
Using multiple tools to avoid limits incurs cognitive overhead:
- Learning different command syntaxes
- Maintaining multiple configurations
- Context does not transfer between tools
- Different capabilities require different approaches
Recommendation: Choose one primary tool and use others only for specific strengths (like Gemini's 1M context window for large codebase exploration).
Cost Optimization Strategies
Strategy 1: Use Multiple Tools Strategically
Instead of paying for the highest tier of one tool, combine tools by strength:
| Task | Best Tool | Reason |
|---|---|---|
| Quick questions, research | Gemini CLI (free) | Preserves paid tool tokens |
| Large codebase analysis | Gemini CLI | 1M token context window |
| Complex multi-file refactoring | Claude Code | Best coherence, reasoning |
| GitHub workflow automation | Copilot CLI | Native integration |
| Screenshot/mockup to code | Codex CLI | Image input support |
| Code review before commit | Codex CLI | Dedicated /review command |
Strategy 2: Maximize Free Tiers
Gemini CLI's free tier can handle a surprising amount of work:
- Use for exploration and research (saves Claude/Codex tokens)
- Run initial codebase analysis before switching to paid tools
- Handle web searches and documentation lookups
- Quick syntax questions and error explanations
Strategy 3: Model Selection for Cost Efficiency
Within each tool, model choice affects costs:
Claude Code: Use Haiku for simple tasks, Sonnet for complex work Gemini CLI: the lighter Flash-class models are usually sufficient; reserve the Pro-class models for genuine reasoning work Codex CLI: use a lighter model for routine edits — reasoning models consume your five-hour window an order of magnitude faster Copilot CLI: under credit billing, model choice and context size multiply, so trimming context matters as much as picking a cheaper model
Strategy 4: Batch Similar Tasks
Instead of frequent small requests:
- Group related questions into single prompts
- Prepare context before starting a session
- Plan your approach to minimize back-and-forth
- Use extended thinking when available for complex tasks
Best Value Recommendations
For Budget-Conscious Developers
Recommended: Gemini CLI (free) + ChatGPT Go ($8/month) or GitHub Copilot Pro ($10/month)
- Total cost: $8-$10/month
- Gemini handles exploration, research, and large reads at no cost
- The paid tier covers agentic editing where Gemini's free quota would be the constraint
- Pick Go if you want Codex's agentic workflow; pick Copilot Pro if your work lives in GitHub and you want metered overage rather than a hard stop
This is the recommendation that changed most since 2025. The old floor was $10; ChatGPT Go moved it to $8, and both Codex and Copilot now have free tiers worth trying before you pay anything at all.
Upgrade path: Add Claude Pro ($20/month) when you need stronger multi-file reasoning.
For Professional Developers
Recommended: Claude Pro ($20/month) + Gemini CLI (free)
- Total cost: $20/month
- Claude Code as primary tool for complex development work
- Gemini for large codebase exploration and research
- The free tier keeps you working when Claude's window is exhausted — which is the specific failure this pairing exists to solve
Upgrade path: Claude Max (from $100/month) if you routinely exhaust Pro mid-session. Try context discipline first; it is free.
For Teams and Enterprises
Recommended: Copilot Business ($19/user/month) + Claude Pro ($20/user/month)
- Total cost: $39/user/month — not the $59 that the widely-quoted $39 Business figure implies
- Copilot for team-wide code suggestions, GitHub integration, and centralized policy
- Claude Code for complex architecture and refactoring
- Step up to Copilot Enterprise ($39/user/month) only if you need custom knowledge bases from your repositories; the management, SSO, and audit features are already in Business
Alternative: organisations standardised on Google Cloud can run Gemini Code Assist alongside Claude Code for consolidated cloud billing and data-residency controls.
Pricing Changes to Watch
AI tool pricing moves faster than almost any other line item in a developer budget. The two changes documented above — GitHub retiring premium requests for credits, and OpenAI adding an $8 tier — both happened inside twelve months, and both invalidated the standing advice in most published comparisons.
What to watch:
- Billing-unit changes, not just price changes. GitHub's shift from request counts to token-metered credits changed who pays more without changing a single headline price. These are the changes that silently break your budget model.
- New tiers below the old floor. ChatGPT Go landed under every existing paid plan. Vendors add downmarket tiers to widen adoption, and they rarely get covered.
- Plan renames. "Copilot Individual" became "Pro," and the old "Pro" name moved to a $39 tier. Renames make stale advice actively wrong rather than merely outdated.
- Free-tier quota adjustments. These move in both directions and are the least announced.
- Enterprise negotiation. Large deployments can negotiate away from list pricing entirely.
Recommendation: verify prices against vendor documentation before any purchasing decision, and re-check quarterly. Every figure on this page was checked on 13 August 2026 and links to its source — treat any pricing article without a verification date, this one included after a few months, as a starting point rather than an answer.
Conclusion
There is no single "best value" AI coding CLI---the right choice depends on your specific needs, budget, and workflow.
If budget is the primary constraint: start with Gemini CLI's free tier — 1,000 requests a day is a real allowance, not a trial — and add ChatGPT Go ($8/month) or GitHub Copilot Pro ($10/month) when you need agentic editing.
If productivity is the priority: Claude Pro ($20/month) plus free Gemini is the highest-value pairing for most professionals. Move to Claude Max (from $100/month) only after you have confirmed that context discipline is not the cheaper fix.
If you are part of an organization: Copilot Business at $19/user/month — not $39 — provides the management, SSO, and policy layer; add Claude Code seats for architecture and refactoring work. Reserve Copilot Enterprise for teams that specifically need repository knowledge bases.
The tools are complementary, not competitive. Claude Pro + Copilot Pro + Gemini free comes to $30/month, which buys three genuinely different model families and is less than most teams spend per seat on a single traditional developer tool.
Choose based on your actual usage patterns, not marketing — and not on pricing figures you have not checked. The single most common costly mistake in this category is budgeting a team rollout against a number that was accurate last year: as of this writing, "$39/user for Copilot Business" and "$0.04 per premium request" are both wrong, and both are still widely repeated.
Related reading: Sandbox and approval modes compared covers the security posture of each CLI's autonomous mode — the other axis you should evaluate before standardising a team on one of these tools.