Cline vs Cursor — does bring-your-own-key actually come out cheaper?
Two cost models, not two intelligences. Cline is a free Apache-2.0 extension on bring-your-own-key: you pay the provider directly, on any model, with no platform fee. Cursor now sells a weekly pool for its own models from $8, and reaches Claude, GPT or Gemini from Premium at $30, billed at list price from prepaid credit on top of the tier. Choose Cline for provider freedom, native JetBrains and a $0 floor; choose Cursor for Tab, Composer 2.5, a published plan ladder and self-serve teams.
| Category | Winner | Margin |
|---|---|---|
| Licence · who owns the client | ACline | Cline is Apache 2.0 with 65.1k GitHub stars and 250+ contributors; Cursor is proprietary |
| Cost floor · what $0 buys | ACline | Cline's tool cost is $0 forever on every surface; Cursor's Free tier limits usage with no stated number |
| Value of a paid tier · what the subscription includes | BCursor | Cursor's tiers buy a weekly pool for its own models, Tab and, from $30, cloud agents and Bugbot. They no longer include third-party usage |
| Rate control · price per token | ACline | Cline pays each provider's live rate; Cursor's own sheet can lag a maker's price change — it lists Gemini 3.6 Flash at twice Google's current rate |
| Model breadth · what you can point it at | ACline | Cline reaches 100+ models via its own provider, 200+ via OpenRouter and local Ollama; Cursor sells a curated catalogue with no local option |
| Tab autocomplete · inline completion | BCursor | Cursor ships Tab on every plan; Cline has none and doesn't attempt it |
| In-house model · vendor's own weights | BCursor | Cursor trains its own Composer 2.5 at $0.50/$2.50 per 1M. It also co-trains the Grok models it sells; Cline has no model at all |
| Editor reach · where it runs | ACline | Cline runs in VS Code, JetBrains, Zed and Neovim; Cursor is its own fork plus JetBrains over ACP on a paid plan |
| Platform fee · surcharge on your tokens | ACline | Cursor Teams adds $0.25/1M on eligible third-party models, including your own key; Cline adds nothing |
| Team onboarding · getting a price | BCursor | Cursor Teams is self-serve from $30/user with SSO and Bugbot; Cline gates SSO and dashboards behind sales |
| Air-gapped deployment · code never leaves | ACline | Cline Enterprise runs in VPC, on-prem or air-gapped; Cursor documents no self-hosted option |
| Data path on your own key · who sees the prompt | ACline | Cline says it doesn't collect BYOK traffic; Cursor routes every request through its servers and voids ZDR on BYOK |
| Best overall | ·Depends | See the decision tree below |
CHOOSE A · CLINE
If you want the bill to be yours — your provider, your rate, your infrastructure.
- Zero tool cost — the extension, CLI, SDK and Kanban board are Apache 2.0 and free; the only invoice is your model provider's
- Any provider — Anthropic, OpenAI, Google, OpenRouter's 200+, Bedrock, Vertex, Groq, Cerebras, DeepSeek, or Ollama running on your own machine
- Native JetBrains — a free Marketplace plugin (v3.5) covering IntelliJ IDEA, Android Studio and 14 more IDEs, with no paid plan attached
- Per-request cost readout — the extension tracks tokens and API cost for each request and for the whole task loop, so spend reconciles against your provider bill
- Air-gapped deploys — Enterprise runs in your VPC, on-premises or fully disconnected, with inference pointed at your own cloud contract
- No routing surcharge — Cursor Teams charges $0.25 per million tokens on eligible third-party models even when the tokens are bought with your key
CHOOSE B · CURSOR
If you want the finished product — autocomplete, a house model, and a price you can read.
- Tab completion — inline autocomplete on every plan, driven by Cursor's own models; Cline offers none at all
- One weekly pool — every paid tier covers Composer 2.5 and the Grok models from a single pool, with no per-token bill until it runs out
- Composer 2.5 — an in-house coding model at $0.50 input and $2.50 output per million, well under any frontier model's rate
- A published ladder — $8 / $30 / $100 / $200 at Base, 4×, 15× and 50×, so heavy users can buy a bigger tier instead of paying per request
- Self-serve teams — from $30/user with SAML/OIDC SSO, Bugbot pull-request review and usage analytics, no sales call required
- Zero Data Retention — Privacy Mode on Cursor's own models, available on the free tier and enforceable team-wide
| Aspect | Cline | Cursor |
|---|---|---|
| Base costPrice of the tool itself | $0 · Apache 2.0 Extension, CLI, SDK and Kanban are free for individuals. You pay only for inference, billed by whichever provider you point it at A wins | $0 · Free Free tier with limited Agent, Chat and Tab usage on Cursor's own models |
| Entry paid tierCheapest subscription on each side | $9.99/mo · ClinePass Optional, not required to use Cline: a flat plan covering a curated set of open-weight models (GLM 5.3, Kimi K3, DeepSeek V4 Pro, MiniMax M3, Qwen3.8-Max and more) at 2–5× standard API quotas. The first-month promotion this row carried in July is no longer offered | $8/mo · Plus $7/mo billed annually. A weekly pool for Cursor's own models at fixed settings, with no Auto, cloud agents, Bugbot, third-party models or own API keys B wins |
| Power-user tierWhere heavy usage lands | ✗ No higher tier There is nothing above ClinePass for individuals — heavier use simply means a larger provider bill at the same per-token rate, with no cliff and no upgrade prompt | $30 Premium · $100 Super · $200 Ultra $25, $84 and $167 billed annually. 4×, 15× and 50× the Plus pool. Premium adds cloud agents, Bugbot, Grok Bot and third-party models at API list price from prepaid credit B wins |
| Team seatPer-user price for a squad | Custom · Enterprise only SSO, role-based access control, centralized billing, a team dashboard and authentication logs are quoted by sales. No per-seat number is published | $30/user/mo · Teams Premium, Super or Ultra seats at $30, $100 or $200, mixable on one team, each with its own weekly pool. Enterprise adds pooled usage, SCIM and audit logs at custom pricing B wins |
| Usage modelHow tokens are actually billed | Pass-through tokens Pay your provider directly at their list rate, or top up Cline credits and spend one balance across 100+ models. Cline states it sells inference at cost A wins | Weekly pool + prepaid credit Cursor's own models (Composer 2.5, Grok 4.7, 4.6, 4.5) draw on the weekly pool. Third-party models bill at each model's API rate from prepaid credit, from the first request |
| Surcharge on your own tokensPlatform fee stacked on the model price | $0 No per-token charge on top of the provider's rate, on any plan or surface A wins | $0.25 per 1M tokens The Cursor Token Rate applies to eligible third-party models on Teams and Enterprise — including usage on your own API key. Cursor's own Composer and Grok models are exempt, and so is a short list of third-party models |
| Rate on a shared modelClaude Sonnet 5, per 1M tokens | $2 in / $10 out Anthropic's live rate, paid direct with no intermediary; the $3/$15 rise once scheduled for Sep 1 was cancelled | $2 in / $10 out Cursor's sheet carries Anthropic's rate to the cent, paid from prepaid credit. Across the rows we could join it matches vendor list on 40 of 41; the miss is Gemini 3.6 Flash |
| Model accessWhat the picker can reach | 100+ hosted, 200+ via OpenRouter, plus local Anthropic, OpenAI, Google, Bedrock, Vertex, Groq, Cerebras, DeepSeek, MiniMax, Z.ai, Qwen, Ollama, LM Studio and any OpenAI-compatible endpoint A wins | 50+ models on the published sheet Claude, GPT, Gemini, Muse, GLM, Kimi K3, DeepSeek V4.1 Flash, Grok and Composer. No MiniMax or Qwen, and no local runtimes |
| Capability | Cline | Cursor |
|---|---|---|
| Open-source licence | ✓ Apache 2.0 · 65.1k stars | ✗ Proprietary |
| Product shape | Extension + CLI + SDK + Kanban board | Standalone VS Code fork + CLI |
| Model choice | ✓ 100+ hosted, 200+ via OpenRouter, local Ollama | ✓ 50+ on the published rate sheet |
| Bring your own API key | ✓ Any provider, every feature | ~ From Premium, chat models only — Tab stays on Cursor's models |
| Requests routed via vendor servers | ✗ Client-side architecture | ✓ All requests route through Cursor's backend |
| In-house model | ✗ None, by design | ✓ Composer 2.5 + Grok 4.7 |
| Tab autocomplete | ✗ Not offered | ✓ On every plan |
| Agent mode | ✓ Native | ✓ Native |
| Plan / Act modes | ✓ Explicit Plan/Act toggle | ✓ Plan Mode |
| Per-action approval | ✓ Every edit and command, or auto-approve | ~ Auto-run with allow/deny controls |
| Checkpoints / rewind | ✓ Shadow-git snapshot per tool use, diff before restore | ✓ Checkpoint restore in-chat |
| Codebase context | ~ AST parse, regex search and on-demand reads — no embeddings index | ✓ Repo embeddings index + semantic search |
| MCP support | ✓ Native + MCP Marketplace, one-click install | ✓ Native |
| Terminal execution | ✓ Native, watches output live | ✓ Native |
| Browser use | ✓ Headless browser with screenshots and console logs | ~ Browser controls governed at Enterprise level |
| Cost visibility per task | ✓ Tokens + API cost per request and per task loop | ~ Usage dashboard plus in-editor pool meters |
| Rules / memory files | ✓ .clinerules, skills, hooks | ✓ Rules, skills, hooks |
| Headless CI runs | ✓ cline --json, pipe-friendly | ✓ Cursor CLI |
| Parallel agents | ✓ Kanban board, a git worktree per card | ✓ Cloud agents with shared team context |
| Scheduled agents | ✓ cline schedule on cron, free tier included | ✓ Automations from Premium |
| Automated code review | ~ Pipe a diff into the CLI | ✓ Bugbot on pull requests |
| JetBrains support | ✓ Native plugin, free on the Marketplace | ~ Via ACP — paid plan + JetBrains AI Assistant 2025.1+ |
| Team / enterprise admin | ✓ Enterprise: SSO, RBAC, OpenTelemetry, audit logs | ✓ Self-serve Teams + Enterprise SCIM and audit logs |
| No-training data path | ✓ On your own key, code goes to your provider — Cline says it doesn't collect it | ~ Privacy Mode covers Cursor's models; ZDR is void on your own key |
| Self-host / air-gapped | ✓ VPC, on-premises or air-gapped | ✗ Not documented |
| Platforms | macOS / Windows / Linux · VS Code, JetBrains, Zed, Neovim | macOS / Windows / Linux |
§ 04 / BENCHMARKS
Why there's no chart here.
No neutral benchmark covers this pair. Cline has no model of its own — you bring an API key and it runs whatever you point it at, so scoring Cline on Claude Sonnet measures Claude Sonnet. The leaderboards agree: Artificial Analysis's Coding Agent Index v1.3 rates only CLI harnesses (Claude Code, Codex, Cursor CLI, Opencode, Gemini CLI) and carries no Cline entry, and Terminal-Bench 2.0's 142 rows contain neither product. AA's separate coding-agent directory lists both, but records licence, category and price — not scores. Vendor-published figures don't qualify here.
A · CLINE BOT
Cline
The open-source agent that never sells you tokens — Apache 2.0, any provider, and a per-request cost readout that reconciles against your own bill.
Strengths
- Nothing to buy — the VS Code extension, JetBrains plugin, CLI, SDK and Kanban board are all free under Apache 2.0, with 65.1k GitHub stars behind them
- Provider freedom — point it at Anthropic, OpenAI, Google, OpenRouter, Bedrock, Vertex, Groq, Cerebras, DeepSeek, MiniMax, Qwen, or a local Ollama runtime
- Transparent spend — the UI tracks tokens and API cost for every request and for the whole task loop, so the number you see matches the provider invoice
- Approval-first execution — Plan mode explores and proposes, Act mode executes, and every file edit and shell command asks first unless you turn auto-approve on
- Shadow-git checkpoints — each tool use snapshots the full file state, including untracked files, and you can diff before restoring files, the task, or both
- Deployable anywhere — Enterprise runs in a VPC, on-premises or air-gapped, pointed at your own Bedrock, Vertex or Azure contract
Weaknesses
- No inline Tab completion at all — it's an agent, not a completion engine, and the feature requests for autocomplete are still open on GitHub
- No in-house model, so quality is entirely whichever model you attach and whatever that provider charges this month
- No embeddings index of the repo — context comes from AST parsing, regex search and on-demand file reads, which can mean more reading on very large codebases
- Team features are Enterprise-only with no published price: SSO, RBAC, dashboards and audit logs all start with a sales conversation
- Cost is unbounded by design — there is no plan ceiling to stop a runaway agent, only your provider's spend limits
Best for
- Developers who already hold provider API keys and want no middleman
- JetBrains shops that need a native plugin rather than a bridge
- Teams standardising on open-weight or Chinese models Cursor doesn't sell
- Regulated environments that need VPC, on-prem or air-gapped inference
- Anyone who wants to audit the agent's source before running it on their codebase
B · ANYSPHERE
Cursor
The AI-native IDE whose subscription is now a pool for its own models — Tab, a house model that undercuts the frontier, and everything else at list price from prepaid credit.
Strengths
- Tab is the moat — inline completion on every plan, driven by Cursor's own models and unavailable through anyone's API key
- One weekly pool — Composer 2.5 and the Grok models draw on a single pool shared with the Grok apps, so a paid tier pays off the longer you stay on Cursor's models
- Composer 2.5 — an in-house agentic coding model at $0.50 input and $2.50 output per million, with a Fast variant at $3/$15 when latency matters
- Honest pass-through — the published rate sheet matches vendor list to the cent on the models we track, GLM 5.2 at $1.40/$4.40 and Kimi K2.7 Code at $0.95/$4.00
- Predictable ladder — $8 / $30 / $100 / $200 at Base, 4×, 15× and 50×, with overage bought as prepaid credit at published rates rather than a penalty tier
- Teams without a meeting — from $30/user self-serve with SAML/OIDC SSO, Bugbot pull-request review, usage analytics and team-wide Privacy Mode
Weaknesses
- A $0.25 per million Cursor Token Rate lands on eligible third-party models for Teams and Enterprise — including tokens bought with your own API key
- BYOK is partial: custom keys drive chat models only, Tab stays on Cursor's models, and Zero Data Retention explicitly does not apply to your own keys
- The model sheet stops short of DeepSeek, MiniMax, Qwen and local runtimes, which is where the cheapest coding tokens currently sit
- No self-hosted or VPC deployment is documented, and every request routes through Cursor's servers for prompt building
- Closed source — you can't read what the harness sends, only what the settings expose
Best for
- Developers whose muscle memory is built on inline completion
- Solo devs whose monthly model spend sits near or under $20 anyway
- Teams that need a per-seat number today rather than a sales cycle
- Shops that want agentic pull-request review bundled in
- Anyone who wants one bill instead of a provider account per model
01
Solo dev working out whether a Cursor plan buys anything
You code with an agent most days and you're deciding between paying Cursor and running Cline against an Anthropic key you already hold.
Reasoning: This used to be close, because Cursor's $20 Pro plan carried a pool of third-party usage about the size of the fee. The plans sold since October 2026 do not. Premium at $30 buys a weekly pool for Cursor's own models; Claude on top of it bills from prepaid credit at list price from the first request. Cline's extension is $0, so the same tokens cost exactly what the provider charges with no tier in front of them. If you stay on Claude, Cline saves you the whole subscription. Cursor earns its price only if you want Tab, Bugbot and Composer as well.
Picked
Cline
Runner-up: Cursor Premium if Tab and Composer 2.5 are what you came for
02
Cost-down team standardising on open-weight models
Quality bar is 'good enough to ship with review', and the mandate is to get cost per task as low as it will go.
Reasoning: Cursor's rate sheet now reaches GLM 5.3, Kimi K3 and DeepSeek V4.1 Flash, but not MiniMax, Qwen or local runtimes, and every third-party row sits behind a tier of at least $30. Cline reaches all of them plus Ollama with no tier at all. DeepSeek V4.1 Flash at $0.30 input and $1.20 output blends to about $0.15 per million tokens on the same 92/8 assumption at peak, about a third of Composer 2.5's $0.43. ClinePass at $9.99/mo flat is the other route to the same lineup with 2–5× the standard API quotas.
Picked
Cline
Runner-up: Cursor Plus on Composer 2.5 if you'd rather not manage provider accounts
03
Twelve-engineer team that wants a price before a meeting
Procurement needs a number this week, and the team wants SSO, centralised billing and some form of code review.
Reasoning: Cursor Teams starts at $30/user, so twelve Premium seats are $360/mo, with SSO, Bugbot review and usage analytics included and no sales call. Two catches. Third-party models are no longer included, so they come out of a shared prepaid balance. And the Cursor Token Rate adds $0.25 per million tokens on eligible third-party models at Teams and above, even on tokens bought with your own key — a team burning 200M third-party tokens a month adds $50 for routing. Cline charges nothing per token, but its SSO, RBAC, dashboards and audit logs are Enterprise-only with no published price. You're trading a known $360 for a quote.
Picked
Cursor
Runner-up: Cline Enterprise if the routing fee or air-gapping outweighs a published seat price
04
Java shop that lives in IntelliJ
Spring and Gradle, JetBrains debugger and profiler, and nobody is migrating to a VS Code fork this quarter.
Reasoning: Cline ships a native JetBrains plugin — v3.5, free on the Marketplace, compatible with IntelliJ IDEA, Android Studio and 14 more IDEs — and it runs on your own keys. Cursor reaches JetBrains too, but through the Agent Client Protocol, and its own docs require a paid Cursor plan plus the JetBrains AI Assistant plugin on 2025.1 or newer. One is a plugin you install; the other is a bridge with a subscription attached.
Picked
Cline
Runner-up: Cursor ACP if you already pay for Cursor elsewhere in the org
05
Regulated org where code cannot leave the building
Compliance requires that source and prompts stay inside infrastructure you control, with inference on a contract you already hold.
Reasoning: Cline's architecture is client-side and Enterprise deploys into a VPC, on-premises or a fully air-gapped environment, pointed at your own Bedrock, Vertex or Azure OpenAI contract. Cursor documents no self-hosted option, and its own BYOK page states that Zero Data Retention does not apply when you use your own keys — every request still routes through Cursor's servers for final prompt building. If the requirement is absolute, only one of these clears procurement.
Picked
Cline
Runner-up: Cursor Enterprise if VPC is a preference rather than a control
06
Developer whose day is half autocomplete
You accept inline suggestions constantly and only reach for an agent on larger refactors.
Reasoning: Cline has no inline Tab completion and doesn't attempt one — the open GitHub discussions asking for it are still open. Cursor includes Tab on every plan, driven by a proprietary model that no API key can substitute for; even Cursor's own BYOK page notes Tab stays on Cursor's models. If half your keystrokes are accepted suggestions, this stops being a pricing question.
Picked
Cursor
Runner-up: Cline alongside a separate completion extension if you want both
Frequently asked.
Common questions about this comparison, with sources where they matter.
Q · 01 Is Cline really free? +
The software is, completely. Cline is Apache 2.0 and the VS Code extension, JetBrains plugin, CLI, SDK and Kanban board all cost $0 for individual developers — Cline's own FAQ puts it as "Cline itself is completely free to use. You only pay for token access." What you pay for is inference. That happens one of three ways: bring your own API key from Anthropic, OpenAI, Google, OpenRouter, Bedrock, Vertex or a local Ollama runtime and pay that provider directly; top up Cline credits and spend one balance across 100+ models, which Cline states it sells at cost; or take ClinePass at $9.99/mo for a curated set of open-weight models at 2–5× standard API quotas. None of those is required — the extension works fine with a key you already own.
Q · 02 Which is better, Cline or Cursor — and why is there no benchmark chart on this page? +
There is no chart because there is no honest number to put in one. Cline has no model of its own: it's a harness you attach an API key to, so any score you measure is the score of Claude, GPT or Gemini running inside it. Cursor at least trains Composer 2.5, but the product people compare is the IDE, not the model. Neutral leaderboards reflect that split — Artificial Analysis's Coding Agent Index v1.3 scores CLI harnesses (Claude Code, Codex, Cursor CLI, Opencode, Gemini CLI) and has no Cline entry at all, and Terminal-Bench 2.0's 142 submissions include neither product. Artificial Analysis does list both in its coding-agent directory, but that table records category, licence and price, not performance. The only Cline coding scores in circulation are vendor-published, which fails our neutral-source rule. So decide on workflow, model access and cost — those differ genuinely and are measurable.
Q · 03 Which one is actually cheaper? +
It depends on which models you want. On Cursor's current plans third-party models are never included: from Premium at $30 they bill at list price from prepaid credit, on top of the tier, so on Claude or GPT Cline is cheaper by the price of the tier itself. Cursor earns its fee when you stay on its own models, because Composer 2.5 and the Grok models draw on the weekly pool and Tab comes with the editor. Holders of the old $20 Pro plan keep an unsized third-party pool, but that plan is no longer sold. Cline also wins on Teams and Enterprise, where Cursor adds a $0.25 per million Cursor Token Rate to eligible third-party models even on your own key, and on models Cursor doesn't sell, such as MiniMax, Qwen and anything local. Run your own numbers in the LLM API cost calculator.
Q · 04 Does Cursor support bring-your-own-key too? +
Yes from Premium up, but partially, and the limits are the point. Cursor accepts keys for OpenAI, Anthropic, Google, Azure OpenAI and AWS Bedrock, and its help page is explicit that "custom API keys only work with chat models" — Tab completion continues using Cursor's built-in models. Requests still route through Cursor's servers for final prompt building, and Cursor's Zero Data Retention policy does not apply when you use your own keys; your data then follows your provider's policy. On Teams and Enterprise the $0.25 per million Cursor Token Rate also applies to BYOK usage. Cline's BYOK has none of those carve-outs: any provider, every feature, no intermediary, no per-token fee.
Q · 05 Can I run Cline inside Cursor? +
Yes — this isn't strictly an either/or. Cline is a VS Code extension, and Cursor is a VS Code fork, so Cline installs into Cursor the same way it installs into VS Code; Cline's own docs list Cursor alongside VS Code, Windsurf, JetBrains, Antigravity, Zed and Neovim. A common setup is paying Cursor for Tab completion and the weekly pool while running longer agent tasks through Cline on a direct provider key, so the expensive runs land on your own API account rather than on prepaid Cursor credit. You're then paying two things, but each for what it's actually good at.
Q · 06 Does either one train on my code? +
Neither claims to, but the data paths differ. With Cline on your own key, code goes straight from your machine to your chosen provider — Cline's privacy notice states that in that case "we do not collect it", and warns separately that some model providers may train on content unless you opt out with them. Cline's client-side architecture and Enterprise VPC, on-prem and air-gapped deployments exist to keep that path short. Cursor's Privacy Mode guarantees code isn't used for training by Cursor or its model providers, is available on every plan including free, and can be enforced team-wide by an admin — but it covers Cursor's own routing, and Cursor's help page states plainly that Zero Data Retention doesn't extend to your own API keys. Check both vendors' current terms before rollout; these policies move.
Q · 07 Which one has better JetBrains support? +
Cline, clearly. It ships a native JetBrains plugin (v3.5 from Cline Bot Inc, free on the JetBrains Marketplace, listed as compatible with IntelliJ IDEA, Android Studio and 14 more IDEs) that runs the same agent core as the VS Code extension and CLI, on your own keys. Cursor reaches JetBrains through the Agent Client Protocol instead — you install it from the ACP registry inside the AI Chat panel, and Cursor's docs require both a paid Cursor plan and the JetBrains AI Assistant plugin on 2025.1 or newer. That route gets you model selection, file editing and terminal commands, but it's a bridge with a subscription rather than a first-class plugin.