Ollama cloud models and cloud API: signin / OLLAMA_API_KEY / usage and balance

Parent: Ollama deployment, cloud, security and operations · Published reference · snapshot 2026-10-14 · skill ollama-expert/references/ollama-ops-platform.md

Also known as: Ollama cloud models and cloud API

↓ Facts as markdown all context files

Ollama Cloud runs larger models on Ollama's own hardware. You reach them through the same CLI and API as a local model, after you sign in with ollama signin. Cloud models carry a cloud tag, such as gpt-oss:120b-cloud, and otherwise behave like any other model name. (from www.ssdnodes.com)

These notes link each claim to its source. Some citations identify archived research reports that are no longer hosted on this site. A published reference means the content is available; it does not certify independent review or accuracy.Read the editorial policy and follow the sources before relying on a claim.

Definitions

Ollama says cloud prompts and responses are processed to answer requests and are not used to train models; refer to the Privacy Policy for detail. [source]

How it works

Tested with baseUrl: "https://ollama.com/api" → Results in 404 (double /api/api/chat path) Tried restarting gateway after config changes Token is confirmed valid via direct API call Issue appears to be in how OpenClaw 2026.3.31 constructs/sends the Authorization header [source]
Ollama Cloud is cheaper when you want models far larger than your RAM allows, and your use is light enough that the included credits cover most months. Buying a GPU machine to run a 120-billion-parameter model a few times a week is hard to justify against a $20 plan. The two also mix well, because the same API serves both local and cloud models. Run small models locally for routine work, and send the hard prompts to a cloud model. [source]
Revoke or rotate the key when it was created for testing. $ export OLLAMA_API_KEY= [source]

How-to and procedures

Set your [API key](https://ollama.com/settings/keys) in `OLLAMA_API_KEY`. No Ollama installation required. [source]
Set your [API key](https://ollama.com/settings/keys) in `OLLAMA_API_KEY`. Install the client with `pip install openai`. No Ollama installation required. [source]
Create or select an Ollama API key for the hosted request. $ export OLLAMA_API_KEY='ollama_********************************' [source]
Set your API key in OLLAMA_API_KEY. Install the client with pip install openai. No Ollama installation required. [source]
To use cloud models, publish models, or download private models, sign in to Ollama. For direct API access to ollama.com, use an API key. [source]
Set `OLLAMA_API_KEY` to your [API key](https://ollama.com/settings/keys), then call a cloud model: [source]
Use cloud models with an API key, or run models locally without one. Cloud requests do not require an Ollama installation. [source]
Ensure OLLAMA_API_KEY is set or it must be passed in the Authorization header. [source]
Set `disable_ollama_cloud` in `~/.ollama/server.json`: [source]

Examples and snippets

```shell theme={"system"} — `curl https://ollama.com/v1/messages \` … [source]
```python theme={"system"} — `import os` … [source]
```shell theme={"system"} — `ollama signin` … [source]
```shell theme={"system"} — `export OLLAMA_API_KEY="your_api_key"` … [source]
```shell theme={"system"} — `curl https://ollama.com/api/tags` … [source]
```shell theme={"system"} — `OLLAMA_NO_CLOUD=1` … [source]
```json theme={"system"} — `"disable_ollama_cloud": true` … [source]
```shell theme={"system"} — `curl http://localhost:11434/api/generate -d '{` … [source]
``` — `ollama run gpt-oss:120b-cloud` … [source]

Problems, failure modes and limitations

Included credit resets monthly on the subscription start day (Free: sign-up date) and does not roll over. Included credit is spent first, then purchased credit balance; buying credits unlocks all models on any plan. Paid plans get an email at 90% of included usage (can be disabled). Requests above the concurrency limit queue, then are rejected when the queue is full. [source]
After updating OpenClaw from version 2026.3.24 to 2026.3.31, all requests to Ollama Cloud models fail with HTTP 401 "unauthorized". The same API key works perfectly when tested directly via curl against the Ollama API. [source]
@Felox63 , I took a leap of faith to upgrade from v2026.3.24 (last version before Ollama Cloud auth starts to fail) to v2026.4.15. Looks like the issue is fixed "somehow" between 4.2 and 4.15 although this ticket is still open. I think we should close this bug. [source]

Comparisons and alternatives

Client bug example: OpenClaw 2026.3.31 sent a synthetic `ollama-local` key instead of the real cloud key, causing HTTP 401 on Ollama Cloud while the same key worked with curl. Setting baseUrl to https://ollama.com/api doubled the path to /api/api/chat (404). Fixed by 2026.4.15. [source]
Before 2026-08-31, Pro/Max/Team cloud usage was limited by 5-hour session and weekly limits tied mainly to GPU time rather than a dollar pool; one source reports a switch to per-token pricing on that date. [source]
Local Ollama (http://localhost:11434) has no rate limits or authentication. Ollama Cloud enforces tier-based concurrency (Free, Pro=3, Max=10 concurrent cloud models) and weekly GPU-time quotas rather than per-second request ceilings. Cloud quotas reset on 5-hour session and 7-day weekly cycles. Specific TPS / RPM ceilings are not publicly documented. [source]
Cloud models can be invoked transparently from a local Ollama instance via signed-in cloud access; routing to localhost vs ollama.com is selected per-request by model name. [source]
The credit model is new. Ollama moved Pro, Max and Team to per-token pricing on 2026-08-31. Before that date, cloud usage was limited by time windows (a 5-hour session limit and a weekly limit) rather than by a dollar pool. Now each plan's included usage resets monthly on the day your subscription started. Unused credit does not roll over. When the pool runs out, you keep going at the published per-token rate for each model, so a heavy month costs more than the sticker price. [source]

Facts and statements

Cloud models need an ollama.com account. After `ollama signin`, Ollama authenticates cloud requests automatically, including requests sent to the local API at localhost:11434. [source]
For direct access, create an API key at ollama.com/settings/keys, store it in OLLAMA_API_KEY and send `Authorization: Bearer $OLLAMA_API_KEY` to https://ollama.com/api (e.g. /api/chat, /api/tags) or https://ollama.com/v1. No local Ollama install is needed. [source]
API keys do not expire and can be revoked in the API keys settings. Docs say to keep them out of browser code and source control. [source]
The hosted Anthropic-compatible /v1/messages endpoint requires the Authorization: Bearer header; an x-api-key header alone is not supported. [source]
The local API at http://localhost:11434 requires no authentication. A 401 on a self-hosted server therefore comes from a proxy or wrapper, not Ollama; OLLAMA_API_KEY and signin apply only to ollama.com. [source]
Model naming differs by surface: the API uses list names such as `gemma4:31b`, while the app/CLI uses `gemma4:cloud`. Cloud models are not downloaded. Usage settings list upcoming model retirements; downloaded local models are unaffected. [source]
Plans as of Oct 2026: Free $0; Pro $20/mo ($200/yr) with $60 monthly usage credit and 3 concurrent requests; Max $100/mo with $300 credit and 10 concurrent; Team $500/mo (early access) with $1,000 shared credit; Enterprise custom. Usage is metered per token at each model's rates. [source]
Usage is checked at ollama.com/settings/usage (docs) and billing at /settings/billing (pricing page). [source]
These examples connect to your local Ollama server. Use `ollama` as the placeholder API key. To use cloud models through this server, [sign in to Ollama](/api/authentication#signing-in). [source]
curl https://ollama.com/api/chat \ -H "Authorization: Bearer $OLLAMA_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "gemma4:31b", "messages": [ { "role": "user", "content": "Say hello in one sentence." } ], "stream": false }' [source]
<RequestExample> ```shell Request theme={"system"} curl https://ollama.com/api/balance \ -H "Authorization: Bearer $OLLAMA_API_KEY" ``` </RequestExample> [source]
<Tabs> <Tab title="Ollama API"> ```shell theme={"system"} curl https://ollama.com/api/chat \ -H "Authorization: Bearer $OLLAMA_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "gemma4:31b", "messages": [ { "role": "user", "content": "Say hello in one sentence." } ], "stream": false }' ``` [source]
| API | Direct cloud access | Local Ollama server | | - | - | - | | Ollama | `https://ollama.com/api` | `http://localhost:11434/api` | | OpenAI compatibility | `https://ollama.com/v1` | `http://localhost:11434/v1` | | Anthropic client base URL | `https://ollama.com` | `http://localhost:11434` | [source]
Ollama supports both local and cloud models. See the currently supported models [here](https://ollama.com/search). [source]
Browse the [cloud model catalog](https://ollama.com/search?c=cloud). Through a signed-in Ollama server, use a cloud name such as `gemma4:cloud` without a separate pull. For direct cloud requests, use the hosted identifier, such as `gemma4:31b`. [source]
Direct cloud requests use the identifiers from `https://ollama.com/api/tags` and do not require a pull. Through a signed-in local server, select a cloud model such as `gemma4:cloud`. [source]
Ollama Cloud runs larger models on Ollama's own hardware. You reach them through the same CLI and API as a local model, after you sign in with ollama signin. Cloud models carry a cloud tag, such as gpt-oss:120b-cloud, and otherwise behave like any other model name. [source]
No. Installing Ollama, pulling open models and running them on your own hardware needs no account and no payment. You only need to sign in with ollama signin to use Ollama Cloud models, including the starter models on the Free plan. [source]
1. Sign in to Ollama's cloud with `ollama signin` 2. In the ollama model settings add a model that ollama hosts, like `gpt-oss:120b`. 3. You can now refer to this model in marimo! [source]
If a cloud model asks you to sign in, run `ollama signin`. [source]
The local API at http://localhost:11434 does not require authentication. To use cloud models, publish models, or download private models, sign in to Ollama. For direct API access to ollama.com, use an API key. [source]
For API requests to ollama.com, use the name returned by this list, such as `gemma4:31b`. In the Ollama app or CLI, use `gemma4:cloud`. Cloud models do not need to be downloaded. [source]
Local server requires no auth. Cloud requires an ollama.com account; pass the API key via the OLLAMA_API_KEY env var or Authorization Bearer header. [source]
Ollama Cloud requests should authenticate successfully using the configured API key, as they did in version 2026.3.24. [source]
Direct cloud inference at https://ollama.com/api and https://ollama.com/v1 requires an API key. No Ollama installation or local server is required. Create an API key, then set it in your terminal: [source]
Direct cloud inference at `https://ollama.com/api` and `https://ollama.com/v1` requires an API key. No Ollama installation or local server is required. [source]
Call cloud models with an [API key](https://ollama.com/settings/keys). No Ollama installation required. Start with the [API quickstart](/quickstart#build-an-application). [source]
Cloud requests need an API key. Local requests do not. To use cloud models through your local server, [sign in to Ollama](/api/authentication#signing-in). [source]
For direct cloud access, set the host to `https://ollama.com` and supply your API key in the `Authorization: Bearer` header. [source]
For cloud models, sign in or create an account, then create an [API key](https://ollama.com/settings/keys). [source]
Read text blocks from `content`. The cloud endpoint requires `Authorization: Bearer`; it does not accept `x-api-key` alone. [source]
* The local server does not validate API keys. Direct cloud inference requires a valid bearer token. * The hosted endpoint rejects `anthropic-version` values older than `2023-06-01`. Use `2023-06-01` in requests. * Token counts are approximations based on the underlying model's tokenizer [source]
Free tier permits running cloud models with basic limits. [source]
This tutorial demonstrates how to implement retrieval-augmented generation (RAG) locally, without the need for API keys or credits. To learn more about RAG, see Retrieval-Augmented Generation (RAG) with MongoDB. [source]
This endpoint allows 10 requests per minute per user, shared across API keys and devices. We recommend polling once per minute. A `429` response includes a `Retry-After` header with the number of seconds to wait before retrying. [source]
Restart Ollama after changing configuration. Once disabled, Ollama's logs will show `Ollama cloud disabled: true`. [source]
Ollama is MIT licensed and free to run on hardware you own. What costs money is Ollama Cloud and the machine with enough RAM to hold the model. [source]
On privacy, Ollama states that its cloud keeps zero data retention, does not log prompts, and does not train on your data. That is a policy you trust, not a property you can check. A local model is the only setup where you can verify that prompts never leave the box. For a longer cost comparison, read Ollama Cloud against running your own server, and for a middle path, running Ollama Cloud models from a small VPS keeps the API on your server while the heavy model runs remotely. [source]
curl https://ollama.com/api/tags [source]
For API requests to ollama.com, use the name returned by this list, such as gemma4:31b. In the Ollama app or CLI, use gemma4:cloud. Cloud models do not need to be downloaded. [source]
If you’re the Ollama team reading this: a single OLLAMA_API_KEY environment variable and a 20-line middleware check is all it takes. The community already wrote the code. Multiple times. You keep rejecting it. [source]
[Bug]: Ollama Cloud Authentication fails with 401 after update to 2026.3.31 #59205 [source]
[Bug]: Ollama Cloud Authentication fails with 401 after update to 2026.3.31#59205 [source]
Have a working setup with Ollama Cloud provider on version ≤2026.3.24 [source]
Attempt to use any Ollama Cloud model (e.g., kimi-k2.5:cloud) [source]
client = OpenAI( base_url="https://ollama.com/v1", api_key=os.environ["OLLAMA_API_KEY"], ) [source]
Direct cloud requests use the identifiers from https://ollama.com/api/tags and do not require a pull. Through a signed-in local server, select a cloud model such as gemma4:cloud. [source]
Yes. Cloud models that are trained to support tools are tested for tool calling and with real agent workflows before they go live. If something isn't working, let us know at [email protected]. [source]
[Usage settings](https://ollama.com/settings) show upcoming retirements for models you've recently used. Switch models before the retirement date. Downloaded local models are not affected. [source]
Ollama processes cloud prompts and responses to answer your requests. We do not use them to train models. Read the [Privacy Policy](https://ollama.com/privacy) for details. [source]
{ "mcpServers": { "web_search_and_fetch": { "type": "stdio", "command": "uv", "args": ["run", "path/to/web-search-mcp.py"], "env": { "OLLAMA_API_KEY": "your_api_key_here" } } } } [source]
Pro tier permits 3 cloud models at a time. [source]
Max tier permits 10 cloud models at a time. [source]
What quantization or data format do cloud models use? [source]
Speed depends on model size, architecture, and hardware optimization. We target and monitor for low time-to-first-token and high throughput across all cloud models. Priority tiers with faster performance may be available in the future. [source]
What happens to my usage if I switch from an existing Pro or Max plan to the new one? [source]
Your usage is reset: the new plan's full monthly amount is available as soon as you switch, and the session and weekly limits of the old plans no longer apply. Your reset date stays on your subscription's original start date. Switch any time from your billing settings. [source]
<Accordion title="Legacy plans"> Plans with session and weekly limits return `session` and `weekly` in `included`: [source]

Related concepts

ollama — is a related of Ollama cloud models and cloud API
api key — is a part of Ollama cloud models and cloud API
usage limits — is a measure of Ollama cloud models and cloud API
11434 — is a related of Ollama cloud models and cloud API
remote_host — is a part of Ollama cloud models and cloud API

Children

No children recorded.

← the whole tree · 3D view· how to read this page