Last updated: October 3, 2026
Ollama Cloud hosts a short list of open-weight models itself and, since August 31, 2026, sells them as a subscription with a monthly credit pool: Pro costs $20 and includes $60 of usage, Max costs $100 and includes $300. OpenRouter hosts nothing; it routes one API key to 500+ open and closed models from 80+ providers at their list prices, plus a 5.5% fee when you buy credits. Ollama Cloud is cheaper for heavy, steady use of the open models it carries. OpenRouter is better for model choice, closed models such as Claude and GPT, irregular usage and failover.
Most “Ollama vs OpenRouter” comparisons you will find were written before August 31, 2026, and they describe a product that no longer exists. Until then, Ollama’s paid cloud plans were metered by GPU time with five-hour session caps and weekly limits. Ollama replaced that with per-token pricing and a dollar-denominated credit pool, and the new numbers change the answer to “which one is cheaper”.
This guide compares the two services as they stand on October 3, 2026: what each one actually is, the published prices, four workloads priced side by side, the limits that matter for coding agents, data handling, and the setup code for both. If you want to run models on your own machine instead, start with our comparison of Ollama vs LM Studio vs llama.cpp.
What is the difference between Ollama Cloud and OpenRouter?
Ollama Cloud is a model host; OpenRouter is a router. Ollama runs a curated set of open-weight models on infrastructure from NVIDIA cloud partners and bills you at its own published per-token rates. OpenRouter owns no GPUs. It forwards each request to one of many third-party providers serving that model, passes through the provider’s price, and charges its fee when you top up your balance.
That single difference explains almost everything else: Ollama offers fewer models but one price and one serving stack per model; OpenRouter offers far more models, several prices and precisions per model, and automatic fallback when a provider fails.
| Ollama Cloud | OpenRouter | |
|---|---|---|
| What it is | Hosted inference for open-weight models | API gateway to many providers |
| Models | 17 cloud models with published token prices (DeepSeek, GLM, Kimi, MiniMax, gpt-oss, Gemma 4, Nemotron, Mistral Large 3) | 500+ models, open and closed (Claude, GPT, Gemini and open weights) |
| Pricing model | Free, Pro $20, Max $100, Team $500 per month, each with included usage credits; pay-as-you-go credits on any plan | Prepaid credits at provider list price; no subscription |
| Fees | No service fees | 5.5% on credit purchases (Standard), 8% (Business); BYOK free up to $25,000 of list-price usage a month, then 5% |
| Free access | Starter credits for a set of starter models | 25+ free models; 50 requests/day, 1,000/day after buying $10 of credits; 20 requests/min |
| Throughput limits | Concurrent requests: Free 1, Pro 3, Max and Team 10; extra requests queue | No plan-based limits on paid models; provider limits apply, with automatic fallback |
| Data handling | Prompts and responses not logged or trained on; zero data retention required from hosting partners | OpenRouter does not retain prompts unless you opt in; provider policies vary; ZDR can be enforced |
| APIs | Native Ollama API, OpenAI-compatible and Anthropic-compatible subsets | OpenAI-compatible API; Anthropic-style endpoint for Claude Code |
| Local option | Yes, the same app runs models on your hardware | No (you can bring your own provider keys) |
Sources: Ollama pricing page and docs, OpenRouter pricing page and docs, checked October 3, 2026.
How much does Ollama Cloud cost after the August 2026 pricing change?
Ollama Cloud now charges per token, and each paid plan prepays you more usage than it costs. On August 31, 2026 Ollama announced that Pro, Max and Team “now use transparent per-token pricing” and that the new plans have “no 5-hour or weekly limits”. Existing subscribers stay on the legacy GPU-time plans until they change tier, billing cycle or re-subscribe.
| Plan | Price | Included usage per month | Concurrent requests | Notes |
|---|---|---|---|---|
| Free | $0 | Starter credits (amount not published) | 1 | Starter models only until you buy credits |
| Pro | $20/month or $200/year | $60 | 3 | Unlocks larger “pro” models |
| Max | $100/month | $300 | 10 | Early access to new models |
| Team (early access) | $500/month | $1,000, shared | 10 | Unlimited users, central billing |
Three rules decide what you actually pay. Included credits are used first, then any credits you bought. Unused included credit does not roll over; it refreshes on your subscription day each month. And once the pool is gone you keep working at the same per-token rate, so a plan is never a hard cap.
The per-token rates are, for most models, the model makers’ own list prices. Kimi K2.6 costs $0.95 per million input tokens, $0.16 cached and $4.00 output on Ollama, which is exactly Moonshot’s price. GLM-5.3 matches Z.ai’s $1.40 / $0.26 / $4.40.
| Model on Ollama Cloud | Input | Cached input | Output |
|---|---|---|---|
| kimi-k3 | $3.00 | $0.30 | $15.00 |
| kimi-k2.6 | $0.95 | $0.16 | $4.00 |
| glm-5.3 | $1.40 | $0.26 | $4.40 |
| deepseek-v4-pro (off-peak) | $1.32 ($0.66) | $0.044 ($0.022) | $3.96 ($1.98) |
| deepseek-v4.1-flash (off-peak) | $0.30 ($0.15) | $0.006 ($0.003) | $1.20 ($0.60) |
| minimax-m2.7 | $0.30 | $0.06 | $1.20 |
| gpt-oss:120b | $0.15 | $0.014 | $0.60 |
| gemma4 | $0.14 | $0.05 | $0.40 |
Prices per million tokens, from Ollama’s pricing page on October 3, 2026. Off-peak rates currently apply to the DeepSeek models outside 12:00–18:00 UTC on weekdays and all weekend.
How does OpenRouter pricing work?
OpenRouter bills each request at the serving provider’s list price and charges a fee only when you buy credits. Its pricing FAQ is explicit: “Inference is billed at the provider’s list price on every plan. OpenRouter’s fee is charged when you buy credits, 5.5% on Standard and 8% on Business, never on individual requests.” There is no subscription and no monthly minimum on Standard.
The catch is that “the price of a model” on OpenRouter is a range. The same open model is often served by a dozen providers at different prices and numeric precisions. On October 3, 2026, OpenRouter listed 18 endpoints for Kimi K2.6:
| Kimi K2.6 endpoint on OpenRouter | Precision | Input | Cached input | Output |
|---|---|---|---|---|
| Inceptron (cheapest) | INT4 | $0.465 | $0.098 | $2.45 |
| DeepInfra | FP4 | $0.75 | $0.15 | $3.50 |
| Crusoe | BF16 | $0.70 | $0.35 | $3.50 |
| Moonshot AI (first party) | INT4 | $0.95 | $0.16 | $4.00 |
| Phala (most expensive) | not stated | $1.09 | $0.37 | $4.60 |
So OpenRouter can be cheaper than the model maker for the same model, but the discount usually comes from a smaller provider, a lower-precision format, or both. Kimi K2.6 was released with native INT4 weights, so INT4 is not a downgrade for that model; for models released in BF16 or FP8, an FP4 endpoint can behave differently on hard reasoning and tool calls. You can pin precision with the quantizations field in provider preferences, and sort by price or throughput.
Free models are real but rate-limited: variants ending in :free allow 20 requests a minute and 50 a day, rising to 1,000 a day once you have bought at least $10 of credits in total. Our list of the best free LLM APIs in 2026 covers how far those quotas go.
Which is cheaper, Ollama Cloud or OpenRouter?
It depends on how close your monthly usage is to an Ollama credit pool. We priced four realistic monthly workloads. “List” is the model maker’s price, which Ollama charges per token; the OpenRouter columns include the 5.5% credit fee.
Ollama: min( pay-as-you-go, $20 + usage above $60, $100 + usage above $300 )
OpenRouter: usage at the chosen endpoint’s price × 1.055
| Workload (per month) | List-price usage | Ollama Cloud | OpenRouter, first-party price | OpenRouter, cheapest endpoint |
|---|---|---|---|---|
| Solo developer, Kimi K2.6: 40M input (70% cached), 2M output | $23.88 | $20 (Pro) | $25.19 | $13.95 (INT4, Inceptron) |
| Heavy agent user, Kimi K2.6: 400M input (80% cached), 20M output | $207.20 | $100 (Max) | $218.60 | $124.03 (INT4, Inceptron) |
| Bulk processing, gpt-oss-120b: 200M input, 40M output, no cache | $54.00 | $20 (Pro) | $56.97 | $14.98 (BF16, DeepInfra) |
| Team coding, GLM-5.3: 100M input (70% cached), 6M output | $86.60 | $46.60 (Pro + $26.60 usage) | $91.36 | $27.41 (FP8, Novita) |
What the table shows:
- Ollama wins when usage lands inside a pool. The heavy Kimi user pays $100 on Max against $124 on the cheapest OpenRouter endpoint and $219 at Moonshot’s price. A plan is a 67% discount on list price, but only on the part of the pool you actually use.
- OpenRouter wins on cheap open models and aggressive providers. For gpt-oss-120b, discount providers charge a quarter of Ollama’s rate, and $15 of usage beats a $20 subscription. For GLM-5.3, an FP8 provider undercuts Ollama’s Pro-plus-overage by about 40%.
- At first-party prices, Ollama is always cheaper than OpenRouter, because Ollama charges the same list price without a 5.5% fee and adds included credit on top.
For the wider question of whether any API beats your own hardware, see our worked example on local LLM vs API cost, and our LLM inference cost comparison for closed-model prices.
Which has better limits for coding agents?
OpenRouter has no plan-level throughput cap on paid models; Ollama caps how many requests run at once. On Ollama, Free runs one request at a time, Pro three and Max ten. Requests beyond that queue, and if the queue is full they are rejected until a slot opens. That matters for agent tools that fan out subagents or run several sessions in parallel: three slots on Pro can feel tight.
On OpenRouter, paid models inherit the provider’s limits, and a provider-side 429 triggers automatic fallback to another provider for the same model. Two OpenRouter-specific errors are worth knowing. A 402 with in_flight_budget_exhausted can hit newer, low-balance accounts that run many paid requests at once, because OpenRouter holds the estimated cost of in-flight requests against your balance. And free :free variants stop at their daily request quota regardless of balance.
Which one is faster?
Neither service publishes a single speed figure you can compare. Ollama says it targets low time-to-first-token and high throughput on every cloud model and lists a Fast mode for Pro as “coming soon”. OpenRouter shows measured throughput and latency for each provider on every model page, and you can route by speed with "provider": {"sort": "throughput"}. If latency matters, benchmark the exact model and endpoint you will use with your own prompt lengths; agent prompts are long, so time-to-first-token usually matters more than tokens per second.
On reliability, OpenRouter’s fallback across providers is its strongest feature. Ollama runs one serving stack per model, and it retires cloud models over time: your usage settings list upcoming retirements for models you have recently used, so pin model names in config and check that list before a release.
Which is better for privacy?
Ollama gives one simple policy; OpenRouter gives you controls you have to switch on. Ollama says prompts and responses are “never logged or trained on”, that it requires “no logging, no training, and zero data retention” from the NVIDIA cloud partners that host its models, and that compute runs primarily in the United States, with capacity in Europe and Singapore.
OpenRouter itself does not retain prompts unless you opt in to logging, but the provider that serves your request has its own policy, and some providers retain data for abuse monitoring. If that matters, enforce zero data retention account-wide or per request with "provider": {"zdr": true}. The Business plan adds EU and US in-region routing. For teams subject to the EU AI Act or GDPR data-transfer rules, document which provider and region actually processed the data; “we used OpenRouter” is not an answer an auditor accepts.
How do you call Ollama Cloud and OpenRouter from code?
Both accept the OpenAI SDK; only the base URL, key and model name change. Ollama’s cloud API does not support stateful Responses or built-in web search through /v1/responses, so use Chat Completions or stateless Responses calls.
import os
from openai import OpenAI
# Ollama Cloud: model names come from GET https://ollama.com/api/tags
ollama = OpenAI(base_url="https://ollama.com/v1",
api_key=os.environ["OLLAMA_API_KEY"])
# OpenRouter: model names use the vendor/model format
openrouter = OpenAI(base_url="https://openrouter.ai/api/v1",
api_key=os.environ["OPENROUTER_API_KEY"])
messages = [{"role": "user", "content": "Explain prompt caching in two sentences."}]
a = ollama.chat.completions.create(model="kimi-k2.6", messages=messages)
b = openrouter.chat.completions.create(
model="moonshotai/kimi-k2.6",
messages=messages,
# pin precision and prefer the cheapest provider
extra_body={"provider": {"quantizations": ["int4"], "sort": "price"}},
)
print(a.choices[0].message.content)
print(b.choices[0].message.content)Using them with Claude Code
Ollama is the simpler path for running open models inside Claude Code. It implements the Anthropic Messages API, and one command configures everything:
# Ollama: sign in once, then launch Claude Code on a cloud or local model
ollama launch claude
# OpenRouter: point Claude Code at the gateway
export ANTHROPIC_BASE_URL="https://openrouter.ai/api"
export ANTHROPIC_AUTH_TOKEN="$OPENROUTER_API_KEY"
export ANTHROPIC_API_KEY="" # must be blank to avoid a direct-Anthropic loginOpenRouter’s own documentation warns that Claude Code through OpenRouter “is only guaranteed to work with the Anthropic first-party provider”. In practice that makes OpenRouter a billing, budget and failover layer for Claude models in Claude Code, not a reliable way to swap in open models. Our guide to running Claude Code for free walks through the local Ollama setup step by step.
Can you use Ollama and OpenRouter together?
Yes, and for many developers that is the best setup. A common split is to run long, open-model agent sessions on an Ollama Pro or Max plan, where the included credit pool makes heavy usage cheap, and keep an OpenRouter key for everything Ollama does not carry: Claude, GPT and Gemini, niche open models, and fallback when one service is down. Because both speak the OpenAI API, switching is a configuration change, not a rewrite. If you also run small models on your own GPU, the same Ollama install serves those locally.
How do you use OpenRouter with Ollama?
Ollama does not forward requests to OpenRouter, so you combine them in your client, not inside Ollama. There are three common ways. Agent tools such as OpenCode and Continue let you configure several OpenAI-compatible providers and pick one per task. A gateway such as LiteLLM can expose both behind one endpoint with fallback rules. Or you add a fallback in your own code, as below: try Ollama first, and send the same request to OpenRouter if Ollama is queued out, rate-limited or down.
import os
from openai import OpenAI, APIError, APITimeoutError, RateLimitError
PROVIDERS = [
# (client, model name on that service)
(OpenAI(base_url="https://ollama.com/v1", api_key=os.environ["OLLAMA_API_KEY"],
timeout=60), "kimi-k2.6"),
(OpenAI(base_url="https://openrouter.ai/api/v1",
api_key=os.environ["OPENROUTER_API_KEY"], timeout=60), "moonshotai/kimi-k2.6"),
]
def chat(messages):
last_error = None
for client, model in PROVIDERS:
try:
return client.chat.completions.create(model=model, messages=messages)
except (RateLimitError, APITimeoutError, APIError) as err:
last_error = err # try the next service
raise last_error
print(chat([{"role": "user", "content": "Summarise RAG in one line."}]).choices[0].message.content)Keep the same model on both sides where you can. Falling back from Kimi K2.6 to a different model changes behaviour mid-task, which is worse for agents than a short wait.
Ollama Cloud or OpenRouter: which should you choose?
| Choose Ollama Cloud if… | Choose OpenRouter if… |
|---|---|
| You spend roughly $20–$300 a month at list price on open models it hosts | Your usage is low, bursty or unpredictable and you dislike subscriptions |
| You want open models in Claude Code, Codex or OpenCode with one command | You need closed models (Claude, GPT, Gemini) behind the same key |
| You want one data policy and no provider roulette | You want to shop for the cheapest provider or a specific precision |
| You also run models locally and want one tool for both | You need failover across providers and per-key budgets for a team |
Our verdict: for a developer who lives in coding agents on Kimi, GLM or DeepSeek models, Ollama Pro is the best value in open-model inference right now, as long as three concurrent requests are enough. For anyone building a product, OpenRouter’s breadth, fallback and closed-model access are worth the 5.5% fee. For the bigger picture of hosted options, see our ranking of the best inference APIs in 2026.
If you are choosing between subscriptions rather than pay-as-you-go, the other contender is OpenCode Go at $10 a month. It beats Ollama Pro on some models and loses on others; see Ollama Cloud vs OpenCode Go.
FAQ
Is Ollama Cloud cheaper than OpenRouter?
At the model makers’ list prices, yes: Ollama charges the same per-token rates without OpenRouter’s 5.5% credit fee, and its Pro and Max plans include three times their price in usage. OpenRouter can be cheaper when a discount provider serves the model below list price, for example gpt-oss-120b or GLM-5.3.
How much does Ollama Cloud cost?
Since August 31, 2026: Free with starter credits, Pro at $20 a month with $60 of included usage, Max at $100 with $300, and Team at $500 with $1,000 shared. Usage beyond the pool is billed at the same per-token rates.
Does Ollama Cloud still have weekly limits?
Not on the new plans. Ollama removed the five-hour and weekly limits when it moved to per-token pricing. Legacy subscribers keep the old limits until they switch, change tier or billing cycle, or re-subscribe.
Does OpenRouter charge a markup on tokens?
No. OpenRouter bills tokens at the provider’s list price and takes a fee when you buy credits: 5.5% on the Standard plan and 8% on Business. With your own provider keys, the first $25,000 of list-price usage each month is fee-free, then 5%.
What are OpenRouter’s free model limits?
Free model variants allow 20 requests per minute and 50 per day. After you have bought at least $10 of credits in total, the daily limit rises to 1,000 requests.
Can I use Ollama Cloud with Claude Code?
Yes. Ollama implements the Anthropic Messages API, and the command ollama launch claude starts Claude Code on an Ollama model without manual environment variables.
Does Ollama Cloud store my prompts?
Ollama says prompts and responses are never logged or trained on, and it requires zero data retention from the partners that host its models. Compute runs primarily in the US, with extra capacity in Europe and Singapore.
How do I use OpenRouter with Ollama?
Combine them in your client. Configure both as OpenAI-compatible providers in a tool such as OpenCode or Continue, put both behind a gateway such as LiteLLM, or add a fallback in code that retries on OpenRouter when Ollama is rate-limited or unavailable.
Sources and further reading
- Ollama — Pricing, plans, model token prices and FAQ (accessed October 3, 2026)
- Ollama — “Ollama’s transparent pricing”, August 31, 2026
- Ollama Docs — Cloud and OpenAI compatibility
- OpenRouter — Pricing and billing FAQ (accessed October 3, 2026)
- OpenRouter Docs — Credit limits and rate limits
- OpenRouter Docs — Zero Data Retention
- OpenRouter Docs — Use Claude Code with OpenRouter
- OpenRouter — Kimi K2.6 providers and prices (endpoint prices via the public models API, October 3, 2026)
