Cohere API Pricing vs Self-Hosted LLMs: Cost & Privacy (2026)

Cohere API pricing for its Command A model is $2.50 per million input tokens and $10.00 per million output tokens, but that number is only half the picture for anyone actually evaluating Cohere. The other half, private deployment, Model Vault, and the North agent platform, carries no public price at all. This post breaks down what the Command A API actually costs, what Cohere's enterprise tracks cost when you ask (which is usually a lot), and what self-hosting Command A or the new Apache 2.0 Command A+ costs on real GPU pricing today. If you're weighing the same question for a different vendor, our Claude Opus 4.8 API pricing vs self-hosted LLMs and GPT-6 vs self-hosted LLMs posts run the same framework at different price points.

Cohere API Pricing for Command A: Input, Output, and What's Missing From the Public Page

Cohere charges $2.50 per million input tokens and $10.00 per million output tokens for Command A, its 111B-parameter flagship model released in March 2025 (cohere.com/pricing; confirmed independently by Artificial Analysis's provider benchmarking). That 1:4 input-to-output ratio means output-heavy workloads, long-form generation, code, agentic tool responses, get expensive fast relative to retrieval or classification tasks that lean on input tokens.

Here's the part that trips people up: Command A doesn't actually appear as a line item on Cohere's own pricing page. The page itemizes legacy Command, Command-light, Command R (03-2024), and Command R+ (04-2024 and 08-2024) in its FAQ, but Command A's rate only shows up through third-party trackers like Artificial Analysis, which test it directly against the live API. If you go looking for "Command A" on cohere.com/pricing expecting a clean row, you won't find one. That's worth knowing before you build a budget off a number you assumed was published.

On performance, Artificial Analysis measured Command A's first-party API at roughly 58-60 tokens/second output speed and a time-to-first-token around 1.6-1.8 seconds, numbers that shift slightly between benchmark runs but land in that range consistently. Blended cost depends heavily on your traffic mix: at Artificial Analysis's 7:2:1 cache-hit:input:output ratio, Command A comes out to $3.25 per million tokens. Run the arithmetic yourself on a flat 80/20 input/output split with no caching and you get:

Blended Command A rate = (0.8 x $2.50) + (0.2 x $10.00) = $2.00 + $2.00 = $4.00/M tokens

That $4.00/M ceiling (uncached) versus $3.25/M (cached) is the range worth budgeting against, not a single number. If your application reuses a large system prompt or document context across turns, prompt caching pulls your real blended rate toward the lower end.

Command A Reasoning, Translate, and Vision variants sit outside all of this: they're gated to evaluation use with no public per-token rate, and production access means emailing sales@cohere.com directly (pricepertoken.com).

Cohere's Own Private-Deployment Options vs Renting GPUs Yourself (SaaS, VPC, Model Vault, North)

The short version: Cohere sells four deployment tracks beyond the public API, SaaS, Private Deployment, Model Vault, and Public/Hybrid Cloud, plus a separate enterprise agent platform called North. Three of those four tracks, and North entirely, have no public price. Getting a number means a sales call, and Cohere doesn't disclose terms even in its published customer case studies.

Cohere's deployment matrix positions SaaS as the option for "non-sensitive workloads," while Private Deployment (on-prem or an isolated VPC) and Model Vault (dedicated, logically isolated managed infrastructure) are pitched as delivering "complete data sovereignty" for regulated industries, running "behind your firewall" with no external data transmission (cohere.com/deployment-options). That's a real distinction from the SaaS API, where every prompt and completion transits Cohere's infrastructure.

Model Vault is the one track where Cohere does publish numbers, but only for its embedding and reranking models, not Command A:

Command A itself carries no listed Model Vault rate. If you want dedicated infrastructure for the generative model specifically, that's a custom quote.

Cohere North, the enterprise agent platform that bundles Command, Compass search, and agent orchestration, has no published pricing at all: the page directs you straight to "Contact sales" and "Request a demo," and highlights case studies like CoreWeave's use of North to overhaul customer support in 90 days (cohere.com/blog/north-ga). Cohere doesn't disclose deal terms for any of these engagements, so budgeting for North means starting a sales conversation with no public number to anchor against.

This is the structural reason renting your own GPUs is worth comparing against Cohere's enterprise tracks in the first place: you get the same "behind your firewall" sovereignty claim Cohere markets for Private Deployment, priced by the GPU-hour instead of a sales negotiation. A Spheron H200 GPU rental has a transparent, published hourly rate you can check on our pricing page right now, no quote required.

Command A+ Changes the Math: Cohere's New Apache 2.0 Open-Weight Model

Cohere shipped Command A+ on May 20, 2026, and it's the most consequential thing to happen to this comparison since Command A itself launched. It's a mixture-of-experts model with 218B total parameters and only 24B active per token, released under a full Apache 2.0 license, and Cohere states it runs on as few as two H100s or a single B200 (cohere.com/blog/cohere-releases-command-a-plus).

Two things changed at once here. First, the license: the original Command A is CC-BY-NC 4.0, which permits internal enterprise use but requires a separate commercial agreement to redistribute or serve as a public-facing product. Command A+ has none of that restriction. Second, the hardware floor: Command A+'s MoE architecture needs two H100s or one B200 as a minimum, a meaningfully smaller and cheaper entry point than the original Command A's dual-H200 (FP16) or single-H200-at-FP8 floor.

Nick Frosst, Cohere's co-founder, framed the release in explicitly sovereignty terms: "The world is building its future on AI systems that offer no guarantee of control. And when only a few big companies control the technology, people have little ability to shape how their AI systems work or evolve. That's why it's so important to prioritize sovereignty now and make sure organizations can own their intelligence layer instead of renting it. Command A+ is part of our effort to make that possible" (cohere.com/blog/cohere-releases-command-a-plus). That's a direct pitch at the same buyer Cohere's Private Deployment and Model Vault tracks target, except now with fully open weights instead of a managed contract. If your interest in Cohere was always about the data-sovereignty story rather than the specific model, Command A+ is worth evaluating before you sign an enterprise quote for Private Deployment.

Command A+ is new enough that we don't have independently verified throughput benchmarks to publish here yet. What we can say with confidence: a model activating 24B parameters per token should process more tokens per GPU-hour than a dense 111B model doing full computation on every token, which should translate into a lower cost-per-token on the same hardware. Benchmark it against your own workload before committing capacity.

Hardware and Cost to Self-Host Command A (VRAM Sizing + Live GPU Pricing)

Command A's 111B dense parameters set VRAM requirements that scale directly with precision. Our Command A self-hosting deployment guide covers the full vLLM setup; here's the sizing summary:

FP8 on a single H200 is the practical sweet spot: it fits without tensor parallelism, and H200's 4.8TB/s memory bandwidth keeps throughput high for a model this size.

Live Spheron GPU pricing, checked 17 Aug 2026:

B200 SXM6 had no on-demand offers live at check time, only spot, which carries reclaim risk. Reverify before you plan production capacity around it.

Applying the throughput assumptions from our deployment guide (roughly 1,800 tok/s on dual H100 FP8, 2,200 tok/s on single H200 FP8, and 3,200 tok/s on single B200 FP8) against current spot rates gives:

Notice the single H200 config beats both the dual-H100 and single-B200 configs on cost per token right now. That's not a fixed rule, it's a function of today's spot pricing: B200 has no on-demand supply at the moment and its spot rate hasn't dropped enough yet to offset the throughput gain, and dual H100 simply carries twice the hourly cost of a single H200 for a smaller throughput jump than you might expect. Check current rates before locking in a config; the ranking between these three shifts with GPU availability, and our H100 GPU rental and B200 GPU rental pages carry live pricing you can compare directly.

Pricing fluctuates based on GPU availability. The prices above are based on 17 Aug 2026 and may have changed. Check current GPU pricing → for live rates.

When Self-Hosting Command A Actually Wins on Cost (Breakeven Table)

Direct answer: Using Cohere's uncached blended rate ($4.00/M at an 80/20 split) against a single H200 SXM5 running Command A at FP8, the crossover lands around 596M tokens/month, roughly 19.9M tokens/day. Below that, the Cohere API is typically cheaper once you count the engineering overhead of running your own inference stack.

The H200 single-node config is the reference point here because it's the best cost-per-token option in the table above. At current spot pricing ($3.31/hr), that's about $2,383/month, a fixed cluster cost regardless of how many tokens you actually process. Since the self-host side is a flat monthly bill rather than a per-token rate, breakeven is just that fixed cost divided by what Cohere would have charged for the same volume:

Monthly H200 cost = $3.31/hr x 24hr x 30 days = $2,383/month

Cohere blended (80/20, uncached) = $4.00/M tokens

Monthly breakeven = $2,383 / $4.00 x 1,000,000 = ~595.8M tokens/month

That works out to roughly 19.9M tokens/day. Here's how the two options compare across daily volume:

Two things move that crossover in either direction. First, prompt caching: if a meaningful share of your traffic hits Cohere's cache reads, your real blended rate drops toward Artificial Analysis's $3.25/M figure, and the breakeven volume climbs to roughly 733M tokens/month (about 24.4M/day) since the API gets relatively cheaper. Second, quantization: dropping to AWQ INT4 on a single H100 cuts the cluster cost further but also cuts throughput, so the net effect on breakeven volume is smaller than the sticker-price drop suggests. Benchmark your actual precision tier before assuming a lower GPU bill translates directly into a lower breakeven.

For teams evaluating Command A+ instead of the original Command A, the entry cost drops even before the cost-per-token math comes into play: a 2x H100 on-demand cluster runs about $7.96/hr, versus committing to a dual-H200 node just to fit the original Command A at FP16. That's a smaller capital commitment before you even factor in the higher tokens-per-GPU-hour a 24B-active MoE model should deliver over a 111B dense model doing full computation on every token. If migrating off a managed API is on your roadmap generally rather than Cohere specifically, our OpenAI API to self-hosted LLM migration guide covers the operational side of that move, and the broader GPU cost-per-token benchmarks post has cross-model throughput data if you're sizing against something other than Command A.

Data Privacy and Compliance: Cohere API vs Self-Hosted Command A

The Cohere API routes every prompt and completion through Cohere's infrastructure. For low-volume or prototype use, that's a reasonable tradeoff for zero setup time. For regulated data, healthcare records, financial documents, anything under HIPAA, GLBA, or the EU AI Act's data-residency provisions, it's the same gap every managed LLM API creates: your data leaves your infrastructure by design.

Cohere's answer to this is Private Deployment and Model Vault, both marketed on "complete data sovereignty" and running "behind your firewall" with no external data transmission (cohere.com/deployment-options). That claim is credible, it's a genuine on-prem or isolated-VPC deployment, but it comes at an undisclosed price, and you're still dependent on Cohere's infrastructure team for support, patching, and scaling decisions on hardware you don't directly control.

Self-hosting Command A or Command A+ on your own rented GPU gets you the same underlying guarantee, prompts and completions never leave hardware you control, without the sales negotiation. On Spheron specifically, that means SSH root access with no shared GPU tenancy and no prompt or completion logging on the provider side, which is the baseline you want before treating self-hosting as a compliance shortcut rather than an assumption. For teams in regulated industries specifically, our HIPAA-compliant GPU cloud guide covers what "self-hosted" needs to mean in practice to actually satisfy an audit, not just in marketing language.

The license matters here too, and it's easy to miss. Command A's CC-BY-NC 4.0 terms let you deploy it internally without a separate Cohere agreement, but serving it as a public-facing product or including it in a SaaS offering to third parties requires a commercial license. Command A+'s Apache 2.0 terms remove that restriction entirely, which is precisely the point Cohere is making by calling it a "sovereign AI" release: full data control and full commercial freedom in one open-weight model, not a compliance workaround bolted onto a research license.

Cohere API Pricing vs Self-Hosted Command A: Decision Framework

Cohere's own family of self-hostable models isn't limited to Command A. North Mini Code, a 30B Apache 2.0 MoE model built for agentic coding, runs on a single H100, see our North Mini Code deployment guide for the setup. And if your RAG stack needs Cohere's embedding models alongside the generative model, our multimodal embedding guide covers self-hosting Embed v4 on the same GPU cluster. For the fine-tuning side of this decision, LLM fine-tuning cost: API vs renting GPUs runs the same framework for customization workloads rather than inference. Spheron's docs cover instance provisioning if you're standing up the self-hosted side for the first time.

If your Command A traffic is approaching the 20M-tokens-a-day range, or you're evaluating the new Apache 2.0 Command A+ for a sovereignty-driven deployment, benchmark it against your own eval set on rented hardware before committing to an enterprise quote.

H200 capacity → | Check current GPU pricing →