API reference

Current as of 2026-10-14

One OpenAI-compatible endpoint. Point an existing client at the base URL, send your key, and everything your SDK already does works: chat, completions, streaming, tool calling, structured output and usage accounting.

Base URL and authentication

https://api.creeksidecompute.ai/v1
Authorization: Bearer YOUR_KEY

Keys come from the account page: sign in with your email and make a key. Each request is paid from your prepaid credit; when it runs out, requests are refused with HTTP 402 and error type insufficient_quota until you add more. Top up by card from $10, or redeem a promotional code. Larger users can ask for a direct agreement, invoiced monthly. One key per project. A key carries a rate limit (see Limits below) and a retention setting (off by default).

Endpoints

Method	Path	What it does
GET	`/v1/models`	The catalogue: model ids with prices, context length and the fields marketplaces read.
POST	`/v1/chat/completions`	Chat, streaming or not. Tool calling and `response_format` JSON schema supported.
POST	`/v1/completions`	Plain completions, streaming or not.
POST	`/v1/messages`	Anthropic's Messages API, for Claude Code and the Anthropic SDKs, streaming or not. The key goes in `x-api-key` or as a bearer token.
POST	`/v1/responses`	OpenAI's Responses API, for Codex CLI, streaming or not. It keeps no state between requests.
POST	`/v1/billing`	`{"requestIds": [...]}` answers the cost of each request in nano-dollars, for marketplaces that reconcile.

Models

Model id	Context	Max output	Input	Output	Cached input
`qwen/qwen3.8-27b`	131,072	65,536	$0.04 / M	$1.35 / M	$0.018 / M
`qwen/qwen3.6-35b-a3b`	131,072	65,536	$0.05 / M	$0.65 / M	$0.025 / M
`meta/muse-glimmer-30b`	131,072	65,536	$0.25 / M	$1.00 / M	$0.03 / M

qwen/qwen3.6-35b-a3b is the faster choice for chat, extraction and high-volume work, at less than half the output price; qwen/qwen3.8-27b is the choice for coding agents and harder reasoning; meta/muse-glimmer-30b, Meta's open model for agents and coding, reads images as well as text and always reasons before it answers (see Sampling and features). Prices are per million tokens on the default, zero-retention tier. The retained tier is 25% lower; see the privacy policy for what it means. GET /v1/models is authoritative.

A request

curl https://api.creeksidecompute.ai/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen/qwen3.8-27b",
    "messages": [{"role": "user", "content": "Explain prefix caching in two sentences."}],
    "max_tokens": 256,
    "stream": true,
    "stream_options": {"include_usage": true}
  }'

Streaming uses server-sent events. With stream_options.include_usage the final chunk carries usage, including prompt_tokens_details.cached_tokens: the part of your prompt that was already in our cache and is billed at the cached price. Reuse a long system prompt or the earlier turns of a conversation and that number climbs.

Sampling and features

temperature, top_p, top_k, presence_penalty, frequency_penalty, repetition_penalty, stop, seed, logprobs and n behave as in the OpenAI API; min_p is accepted on chat completions and has no effect. Tool calling uses tools and tool_choice; structured output uses response_format with json_schema. Thinking is off unless you ask for it. Turn it on per request with "reasoning": {"enabled": true} (OpenRouter style), "reasoning_effort": "medium" (OpenAI style; none and minimal keep it off, any other level turns it on) or "chat_template_kwargs": {"enable_thinking": true} (vLLM style). For a client that cannot send any of these, add :thinking to the model id, as in qwen/qwen3.8-27b:thinking: the same model and price, with thinking on for every request. The thinking text comes back in reasoning beside content, and thinking tokens are billed as output.

Muse Glimmer 30B always reasons before it answers, so none of these switches turns its reasoning off; they set how long it reasons. By default it reasons briefly, at low. reasoning_effort, or OpenRouter's reasoning.effort, raises that to medium, high or xhigh; none and minimal act as low, and max as xhigh. Turning thinking on without an effort, with "reasoning": {"enabled": true}, enable_thinking or :thinking, gives high. A request that sets chat_template_kwargs.reasoning_strength itself keeps it. On one short request on 2026-10-14, low answered in 2.0 s and high in 6.1 s. The reasoning counts toward max_tokens, so leave it room: a limit of a hundred or so tokens can end inside the reasoning, before any answer. It also reads images, sent as image_url parts with base64 data URLs.

Headers

Header	Direction	Effect
`x-creekside-retention`	request	`none` on any request means it is never stored, whatever the key's tier. `store` opts a single request in under a zero-retention key. The header always wins.
`Idempotency-Key`	request	Retry a dropped request with the same key within ten minutes and you get the same answer, not a second bill. A replay carries `x-idempotent-replayed: true`.
`x-request-id`	both	Send one and we adopt it; otherwise we generate one. It is on every response and every support conversation starts with it.
`Retry-After`	response	On 429 and 503: seconds to wait before retrying.

Limits

Keys from the account page allow 60 requests per minute each, with up to 4 requests running at once per account, rising to 600 a minute and 16 at once when the account's purchases reach $25. Keys under a direct agreement allow 600 requests per minute by default, more on request. Prompts up to 131,072 tokens; outputs up to 65,536. Under load a request waits up to 20 seconds for room; if none frees up it gets a 429 with Retry-After, so retry with backoff. A request is never silently dropped. First-token time is what we optimise: on Qwen3.8 27B the first token came in 176 ms on a short prompt, measured through the public endpoint on 2026-10-14.

Errors

Errors are OpenAI-shaped: {"error": {"message", "type": "gateway_error", "code"}}.

Status	Code	Meaning
401	`missing_api_key`, `invalid_api_key`	No bearer header, or a key we do not know.
402	`insufficient_credit`	Your prepaid credit does not cover the request. `type` is `insufficient_quota`, as in OpenAI's own out-of-credit error. Add credit on the account page.
400	`invalid_json`, `missing_model`	The body did not parse, or has no `model`.
400	`context_too_long`	The prompt exceeds the model's window.
404	`model_not_found`	No model by that id is serving right now. `/v1/models` lists every model we price, with `is_ready` false while it is not serving.
409	`idempotency_in_progress`	A request with the same `Idempotency-Key` is still running.
429	`rate_limited`, `capacity`	Over your key's rate, or the model stayed busy through the wait described under Limits. While your account runs only on promotional credit, `capacity` comes at once, with no wait, whenever capacity is busy. Honour `Retry-After`.
429	`account_concurrency`	Your account already has its limit of requests running. Retry when one finishes.
503	`no_capacity`	The model is listed but cannot answer right now. Honour `Retry-After`.
502	`upstream_unavailable`	Every attempt failed before the first byte. Safe to retry.

Data

By default nothing you send or receive is written to disk. Every request leaves an accounting record (ids, timestamps, token counts, cost) and no content. The privacy policy has the whole of it; the content policy says what the API may be used for.

Clients

Anything that speaks Chat Completions and takes a custom base URL works. Claude Code and Codex CLI connect directly as well: this API also serves Anthropic's Messages API at /v1/messages and OpenAI's Responses API at /v1/responses. Each of these tools has a setup page with numbered steps, a copy-paste config, thinking on and off, what does not work, and fixes for common errors:

Terminal agents: Claude Code, Codex CLI, OpenCode, pi, Aider.
Editors: Cline, Kilo Code, Zed.
Agents: Hermes Agent, OpenClaw.
Code: the OpenAI SDKs for Python and JavaScript.

The home page shows the short version of each.