Setup recipes

export OLLAMA_API_KEY="your-key-here"

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 five words."}],
    "stream": false
  }'

import os

from openai import OpenAI

client = OpenAI(
    base_url="https://ollama.com/v1",
    api_key=os.environ["OLLAMA_API_KEY"],
)

reply = client.chat.completions.create(
    model="gemma4:31b",
    messages=[{"role": "user", "content": "Say hello in five words."}],
)
print(reply.choices[0].message.content)

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://ollama.com/v1",
  apiKey: process.env.OLLAMA_API_KEY,
});

const reply = await client.chat.completions.create({
  model: "gemma4:31b",
  messages: [{ role: "user", content: "Say hello in five words." }],
});
console.log(reply.choices[0].message.content);

ollama launch claude
ollama launch codex
ollama launch opencode

import os
import time

from openai import APIConnectionError, APIStatusError, OpenAI

# max_retries=0: the SDK must not retry on its own, or it would also retry a monthly-limit 429.
CLOUD = OpenAI(base_url="https://ollama.com/v1", api_key=os.environ["OLLAMA_API_KEY"], max_retries=0)
LOCAL = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama", max_retries=0)  # local server ignores the key

# Tried in order. Cloud names come from https://ollama.com/api/tags, local names from "ollama list".
CHAIN = [
    (CLOUD, "glm-5.3-flash"),
    (CLOUD, "gemma4:31b"),
    (LOCAL, "your-local-model"),
]


def ask(prompt: str) -> str:
    for client, model in CHAIN:
        for attempt in range(3):
            try:
                reply = client.chat.completions.create(
                    model=model,
                    messages=[{"role": "user", "content": prompt}],
                    max_tokens=2048,  # thinking models need room for reasoning and the answer
                )
                return reply.choices[0].message.content or ""
            except APIConnectionError:
                break  # this endpoint cannot be reached: next model in the chain
            except APIStatusError as err:
                if err.status_code == 429 and "monthly usage limit" in str(err):
                    raise  # the account is capped: no model switch or retry helps until the reset or credits
                if err.status_code not in (429, 502):
                    raise  # a bug in the request, not a capacity problem
                if attempt < 2:
                    time.sleep(2 ** attempt)  # exponential backoff: 1 s, then 2 s
    raise RuntimeError("Every model in the chain failed.")

import OpenAI from "openai";

// maxRetries: 0 stops the SDK retrying on its own, so the loop below decides every retry.
const CLOUD = new OpenAI({ baseURL: "https://ollama.com/v1", apiKey: process.env.OLLAMA_API_KEY, maxRetries: 0 });
const LOCAL = new OpenAI({ baseURL: "http://localhost:11434/v1", apiKey: "ollama", maxRetries: 0 }); // ignores the key

// Tried in order. Cloud names come from https://ollama.com/api/tags, local names from "ollama list".
const CHAIN = [
  { client: CLOUD, model: "glm-5.3-flash" },
  { client: CLOUD, model: "gemma4:31b" },
  { client: LOCAL, model: "your-local-model" },
];

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

export async function ask(prompt) {
  for (const { client, model } of CHAIN) {
    for (let attempt = 0; attempt < 3; attempt++) {
      try {
        const reply = await client.chat.completions.create({
          model,
          messages: [{ role: "user", content: prompt }],
          max_tokens: 2048, // thinking models need room for reasoning and the answer
        });
        return reply.choices[0].message.content ?? "";
      } catch (err) {
        const text = String(err?.message ?? err);
        if (err?.status === 429 && text.includes("monthly usage limit")) throw err; // capped: stop
        if (err?.status === 429 || err?.status === 502) {
          if (attempt < 2) await sleep(1000 * 2 ** attempt); // exponential backoff: 1 s, then 2 s
          continue;
        }
        if (err?.status === undefined) break; // connection failure: next model in the chain
        throw err; // a bug in the request, not a capacity problem
      }
    }
  }
  throw new Error("Every model in the chain failed.");
}

Credential type: OpenAI
API key:         <your Ollama API key>
Base URL:        https://ollama.com/v1

Credential type: Header Auth
Name:            Ollama API key
Header name:     Authorization
Header value:    Bearer <your Ollama API key>

# Read the three usage ranges, one read every 12 seconds (about five reads a minute is the limit).
for range in 24h 7d 30d; do
  curl -s "https://ollama.com/api/usage?range=$range" \
    -H "Authorization: Bearer $OLLAMA_API_KEY"
  echo
  sleep 12
done

# Account and plan. POST only: a GET returns 405.
curl -s -X POST https://ollama.com/api/me \
  -H "Authorization: Bearer $OLLAMA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{}'