Using the API

Quickstart

curl https://api.goedelmachines.com/v1/chat/completions \
  -H "Authorization: Bearer $GOEDEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "deepseek/deepseek-v4.1-flash",
       "messages": [{"role": "user", "content": "Hello!"}]}'

List the model with GET /v1/models.

Signed in? Try it in the Playground: chat with the model in your browser, no code needed.

OpenAI SDK

Python:

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.goedelmachines.com/v1",
    api_key=os.environ["GOEDEL_API_KEY"],
)

resp = client.chat.completions.create(
    model="deepseek/deepseek-v4.1-flash",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(resp.choices[0].message.content)

JavaScript / TypeScript:

import OpenAI from "openai";

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

const resp = await client.chat.completions.create({
  model: "deepseek/deepseek-v4.1-flash",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(resp.choices[0].message.content);

Connect your coding agent in one command

The installer finds the coding agents on your machine, gets you a key through your browser (free or paid, your choice) and configures each agent to use DeepSeek V4.1 Flash here. It backs up every file before changing it, and --uninstall removes what it added.

curl -fsSL https://inference.goedelmachines.com/install.sh | sh

It configures OpenCode, Codex CLI, Claude Code, Aider, Crush, Goose, Continue, oh-my-pi and pi, and prints setup steps for Kilo Code, Cline and Roo Code. The key is saved once in ~/.config/goedel/api_key. The installer says which key type (free or paid) it set up. OpenCode, Claude Code, Crush, Continue, oh-my-pi and pi also show it in the model name, and Codex CLI and Goose in the provider name; Aider and the manual steps for Kilo Code, Cline and Roo Code don't show it. Use --dry-run to see the changes first, --list to see where each agent's settings go, and --new-key to sign in again for a new key, for example to switch to a paid key. You can read the script at /install.sh before running it.

Claude Code gets its own settings file and your ~/.claude is not touched. Start it with the line below; plain claude still uses your own account.

claude --settings ~/.config/goedel/claude-code.json

Get a key from an agent or script

An agent, installer or script can get a key without a browser of its own, the way gh auth login works: it asks for a code, you approve the code while signed in, and it collects the key. When you approve you choose the key: free (prompts are stored, under the free-tier terms) or paid (zero data retention, drawing on your credit; it needs a positive balance). Either way it is an ordinary key: it shows on your Keys page and counts towards your 5 keys.

1. POST /api/device/code on this site, optionally with {"client_name": "my-agent"}. The answer has a user_code (like ABCD-1234), a verification_uri_complete to show the user, a device_code to keep secret, expires_in (600 seconds) and interval (5 seconds).
2. The user opens the link, signs in, and approves a free or a paid key. The page names the client so they know what they approve.
3. POST /api/device/token with {"device_code": "..."} every interval seconds. Until the user answers it returns 400 with authorization_pending; then 200 with api_key, base_url, model, key_name and tier ("free" or "paid"; the key starts sk-gm-free- or sk-gm-paid- to match). The key is returned once.

SITE=https://inference.goedelmachines.com
resp=$(curl -s -X POST $SITE/api/device/code \
  -H "Content-Type: application/json" -d '{"client_name": "my-agent"}')
echo "Open $(echo "$resp" | jq -r .verification_uri_complete) and approve"
code=$(echo "$resp" | jq -r .device_code)
wait=5
while sleep $wait; do
  out=$(curl -s -X POST $SITE/api/device/token \
    -H "Content-Type: application/json" -d "{\"device_code\": \"$code\"}")
  key=$(echo "$out" | jq -r '.api_key // empty')
  [ -n "$key" ] && break
  case $(echo "$out" | jq -r .error) in
    authorization_pending|key_limit|no_credit) ;;
    slow_down) wait=$(echo "$out" | jq -r .interval) ;;
    *) echo "$out" | jq -r .error_description; exit 1 ;;
  esac
done
export GOEDEL_API_KEY=$key

Every error carries an error_description to show the user. Both endpoints are rate-limited per address (429 with Retry-After). Agents can read all of this as plain text at /llms.txt.

Zero data retention (paid keys and routers)

There is one endpoint for everyone: https://api.goedelmachines.com/v1. The key you send decides the data policy.

Every response carries a header that states which policy covered it: X-Data-Policy: retained for free keys, X-Data-Policy: none for paid keys and the platforms.

curl -s -D - -o /dev/null https://api.goedelmachines.com/v1/chat/completions \
  -H "Authorization: Bearer $GOEDEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "deepseek/deepseek-v4.1-flash", "max_tokens": 1,
       "messages": [{"role": "user", "content": "Hi"}]}' \
  | grep -i x-data-policy

x-data-policy: retained

To use the API without retention, use a paid key (or OpenRouter† or Hugging Face†). With a free key you can delete your account and ask us to delete your data at any time.

† Coming soon.

Paid keys

A paid key draws on prepaid credit and stores nothing you send: every response carries X-Data-Policy: none. Add credit on Billing (buyers in India, in rupees, from ₹100 before GST), then choose Paid when you create a key on the Keys page. Credit never expires; prices are on Models.

• Up to 8 requests in flight, 300 requests per minute and 300,000 uncached input tokens per minute per account, with no daily token cap.
• When your balance is used up, requests get 402 with insufficient_balance until you add credit. A request already running when the balance reaches zero finishes and is charged, so the balance can go slightly negative; the next top-up covers that first.

Student pass

Free, for a university email: sign in with an address at a domain ending in ac.in, edu or edu.in (alumni addresses don't qualify), and your free keys get the Student pass on their own. It is the free tier with 3× its daily limits and 4 requests at once:

• 3,000,000 output tokens and 30,000,000 new input tokens per day; cached input is free.
• 4 requests in flight, 120 requests per minute and 200,000 new input tokens per minute.
• It shares capacity with the free tier, at the same priority: when the free tier is busy, student requests wait or are limited like free ones.
• Prompts and completions are kept, as for free keys (Free tier policy).

Streaming

Set stream=True to get server-sent events. While a long prompt is being processed we send keep-alive comments, so the connection stays open. Ask for include_usage to get token counts in the last chunk.

stream = client.chat.completions.create(
    model="deepseek/deepseek-v4.1-flash",
    messages=[{"role": "user", "content": "Write a haiku about GPUs."}],
    stream=True,
    stream_options={"include_usage": True},
)
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
    if chunk.usage:
        print("\n", chunk.usage)

Tool calling

Pass tools and, if you want to force a choice, tool_choice.

tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Current weather for a city",
        "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"],
        },
    },
}]

resp = client.chat.completions.create(
    model="deepseek/deepseek-v4.1-flash",
    messages=[{"role": "user", "content": "Weather in Hyderabad?"}],
    tools=tools,
)
call = resp.choices[0].message.tool_calls[0]
print(call.function.name, call.function.arguments)

Reasoning

Reasoning is on by default and comes back in reasoning (delta.reasoning when streaming), separate from the answer in content. Reasoning tokens count as output. To turn it off, send "chat_template_kwargs": {"thinking": false} in the request body (extra_body in the OpenAI SDK).

resp = client.chat.completions.create(
    model="deepseek/deepseek-v4.1-flash",
    messages=[{"role": "user", "content": "Hello!"}],
    extra_body={"chat_template_kwargs": {"thinking": False}},
)

Model

DeepSeek V4.1 Flash with its original weights (FP8, with FP4 experts), served on our own NVIDIA RTX PRO 6000 Blackwell GPUs in Hyderabad, India. deepseek-v4.1-flash is also accepted as the model id.

Prompt caching is automatic: repeated prompt prefixes, such as a long chat history, are served from cache and answer faster.

Errors

Context and payload limits

1M-token context (1,048,576 tokens). Input and generated output share this window. Output, concurrency, request-rate and daily allowances depend on your plan: see the public Free, Student and Paid limits.

The public endpoint currently accepts request bodies up to 32 MiB (33,554,432 bytes). The full JSON body counts, including base64 screenshots, message history and tool outputs. This byte limit is separate from the model's token context window.

The browser Playground has a separate 4,000,000-byte request limit. Use the API directly for larger screenshots and histories. If a cached connection still reports the previous API limit after an update, reconnect and allow DNS to refresh.

Help

Write to hi@goedelmachines.com.