go2llm API documentation

One account, one USD balance, and API keys for published AI models. The Anthropic-compatible base URL is https://go2llm.tech; the OpenAI-compatible base URL is https://go2llm.tech/v1.

Quickstart

1. Register and create an API key in the dashboard.
2. Fetch the current catalog with GET /v1/models.
3. Choose a model ID and one of its declared endpoints.
4. Send a short request and check the charge in the dashboard.

curl https://go2llm.tech/v1/messages \
  -H "x-api-key: YOUR_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{"model":"MODEL_ID_FROM_CATALOG","max_tokens":120,"messages":[{"role":"user","content":"Reply: OK"}]}'

Authentication

API requests use a user API key. OpenAI-compatible endpoints accept Authorization: Bearer YOUR_API_KEY; Anthropic Messages also accepts x-api-key: YOUR_API_KEY. Dashboard registration and sign-in support email/password, Google, and Telegram. A browser dashboard session does not replace an API key.

Getting and using an API key

Create a key on the keys tab, save the value when it is shown, and never place it in browser JavaScript, a repository, a screenshot, or a support message. Use separate keys for production, development, and CI. Each key has an independent default limit of 20 RPM.

Every documentation example uses only the safe YOUR_API_KEY placeholder.

Model catalog

The table below is built from the same live catalog as GET /v1/models. It lists available models, their exact IDs, prices, capabilities, and endpoints — use them as published; the table updates with each published snapshot.

A single model can be fetched on its own: GET /v1/models/{id} returns the same record as one element of the /v1/models array and also needs no key. Aliases resolve, but the response id is canonical — asking for claude-sonnet-5 returns claude-sonnet-4-5, so the substitution is visible immediately. An unknown ID returns 404 model_not_found.

curl https://go2llm.tech/v1/models/MODEL_ID_FROM_CATALOG

Endpoint selection

Use only an endpoint declared for the selected model:

• messages → POST /v1/messages using the Anthropic format;
• chat.completions → POST /v1/chat/completions using the OpenAI format;
• images.generations → POST /v1/images/generations;
• images.edits → POST /v1/images/edits (image-to-image).

An incompatible model ID and endpoint pair returns 400 model_protocol_mismatch.

POST /v1/responses never appears in endpoints: that field lists what a model sells, not how you may talk to it. The route serves exactly the same models as chat.completions.

Anthropic Messages

curl https://go2llm.tech/v1/messages \
  -H "x-api-key: YOUR_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{"model":"MODEL_ID_FROM_CATALOG","max_tokens":120,"messages":[{"role":"user","content":"Reply: OK"}]}'

This route is available to models that declare the messages endpoint.

OpenAI Chat Completions

curl https://go2llm.tech/v1/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "content-type: application/json" \
  -d '{"model":"MODEL_ID_FROM_CATALOG","max_tokens":120,"messages":[{"role":"user","content":"Reply: OK"}]}'

This route is available to models that declare the chat.completions endpoint.

OpenAI Responses API

POST /v1/responses accepts the OpenAI Responses API format and works as an adapter over chat.completions: same models, same reservation, same charge, same usage.cost_usd. A model that declares only messages in the catalog is not reachable through this route.

from openai import OpenAI

client = OpenAI(api_key="YOUR_API_KEY", base_url="https://go2llm.tech/v1")

response = client.responses.create(
    model="MODEL_ID_FROM_CATALOG",
    instructions="Answer in one line.",
    input="Reply: OK",
    max_output_tokens=64,
)

print(response.output_text)

Supported: input as a string or an array, instructions, tools and tool_choice in the flat Responses form, function_call and function_call_output, max_output_tokens, stream, parallel_tool_calls, response_format.

The shim is stateless: the gateway stores no response history. previous_response_id, store: true, and background: true are rejected with 400 stateful_responses_unsupported — send the whole history in input. Streaming and tool-call examples: Responses API.

Token counting

POST /v1/messages/count_tokens accepts the same body as POST /v1/messages (model, messages, system, tools) and returns the input size. A key is required, but nothing is reserved and nothing is charged — the call is free. Separate limit: 60 RPM per key.

curl https://go2llm.tech/v1/messages/count_tokens \
  -H "x-api-key: YOUR_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{"model":"MODEL_ID_FROM_CATALOG","messages":[{"role":"user","content":"Reply: OK"}]}'

{
  "input_tokens": 14,
  "go2llm": { "exact": false, "method": "byte_estimate", "typical_error_pct": null }
}

This is a byte-based estimate, not a vendor tokenizer. The go2llm block says so explicitly with exact: false. Use it to decide whether a context fits the window and to ballpark cost; do not use it as an exact billing counter. Actual token counts and the actual price are in the usage block of a real model response.

typical_error_pct comes back null: we have not measured how far the estimate drifts from the real count, so we do not publish a figure. Once the estimator is calibrated against accumulated usage, this field will carry a number.

Streaming

Send stream: true and read SSE until the normal final event. Do not automatically retry after the first meaningful SSE fragment: fallback is disabled after a response begins.

Tool calls

For models whose public capabilities include tool, send tools and tool_choice in the selected protocol's format. A tool definition includes its name, purpose, and argument JSON Schema. Your application executes the tool; the model only requests the call.

Images and published capabilities

For image understanding, choose a text model whose modalities.input in GET /v1/models includes image. Every text-only model publishes a vision_companion: the closest available multimodal model, from the same family when possible. Audio, video, PDF, and other unsupported blocks return 400 unsupported_content_type.

Image generation is available only when the live catalog declares images.generations. Send a published size, quality, and allowed result count. Use a unique Idempotency-Key for a media request and reuse it only with an identical body.

curl https://go2llm.tech/v1/images/generations \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Idempotency-Key: project-image-0001" \
  -H "content-type: application/json" \
  -d '{"model":"MODEL_ID_FROM_CATALOG","prompt":"Minimal API diagram","n":1,"size":"1024x1024","quality":"standard","response_format":"url"}'

Image-to-image works for models whose endpoints include images.edits. Send the source image as a file, the same way the OpenAI SDK does (client.images.edit(image=open("photo.png", "rb"), ...)). Up to 4 PNG, JPEG or WebP files go in as image[]. The price per result is the same as generation.

curl https://go2llm.tech/v1/images/edits \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Idempotency-Key: project-edit-0001" \
  -F model=MODEL_ID_FROM_CATALOG \
  -F "prompt=Make the background white" \
  -F size=1024x1024 \
  -F image=@photo.png

Unpublished capabilities are not part of the contract.

Claude Code

Claude Code does not take any catalogue model — only one whose endpoints list in GET /v1/models includes messages. A catalogue model without it answers 400 model_protocol_mismatch. One line prints the list:

curl -s https://go2llm.tech/v1/models \
  | python3 -c 'import json,sys; print(*(m["id"] for m in json.load(sys.stdin)["data"] if "messages" in m.get("endpoints",[])), sep="\n")'

export ANTHROPIC_BASE_URL=https://go2llm.tech
export ANTHROPIC_AUTH_TOKEN=YOUR_API_KEY
export ANTHROPIC_MODEL=claude-opus-4-8
export ANTHROPIC_SMALL_FAST_MODEL=claude-haiku-4-5
claude

Claude Code calls ANTHROPIC_SMALL_FAST_MODEL on its own for housekeeping, so it needs the messages endpoint too.

Use ANTHROPIC_AUTH_TOKEN: if Claude Code is already signed in with a personal account on this machine, ANTHROPIC_API_KEY can lose to that stored login, and the request never reaches go2llm — you get 401 instead.

Codex

Recent Codex CLI (@openai/codex) versions only support wire_api = "responses" for custom providers — the OpenAI Responses API format. That used to be the reason it failed: go2llm had no /v1/responses route, so Codex got a 404.

POST /v1/responses is now published and was verified by a live Codex CLI 0.151.0 run on 2026-09-14: codex exec read a file in a test project, executed tools and applied the edit. The run used the qwen3-8-flash model; we did not exercise the interactive codex TUI. The ~/.codex/config.toml setup and the limits of that check live on the coding tools page and on Codex API (in Russian).

OpenAI SDK

import OpenAI from "openai";

const client = new OpenAI({ apiKey: "YOUR_API_KEY", baseURL: "https://go2llm.tech/v1" });
const response = await client.chat.completions.create({
  model: "MODEL_ID_FROM_CATALOG",
  messages: [{ role: "user", content: "Reply: OK" }],
});

Anthropic SDK

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({ apiKey: "YOUR_API_KEY", baseURL: "https://go2llm.tech" });
const response = await client.messages.create({
  model: "MODEL_ID_FROM_CATALOG",
  max_tokens: 120,
  messages: [{ role: "user", content: "Reply: OK" }],
});

Python

from openai import OpenAI

client = OpenAI(api_key="YOUR_API_KEY", base_url="https://go2llm.tech/v1")
response = client.chat.completions.create(
    model="MODEL_ID_FROM_CATALOG",
    messages=[{"role": "user", "content": "Reply: OK"}],
)

JavaScript and TypeScript

Use the OpenAI SDK for chat.completions and the Anthropic SDK for messages. Send the exact model ID from the catalog, set a reasonable max_tokens, and inspect the HTTP status before reading the response body. Keep the server-side key as YOUR_API_KEY; never ship it in a browser bundle.

That rule is enforced, not merely written down: Access-Control-Allow-Origin: * is set on public reads only — GET /v1/models, GET /v1/models/{id}, GET /api/pricing, GET /status. Routes that take a key deliberately have no CORS, and OPTIONS to them answers 405 with an explanation: call go2llm from your server. Reading the catalog and prices from a browser is fine — building a model picker, for example.

cURL

cURL examples appear in quickstart and the endpoint sections. Add -i while diagnosing to inspect the HTTP status and Retry-After, but never publish a command containing a real key.

Other clients

Use another client only after verifying that it supports a custom base URL, sends the required header, calls a published endpoint, and correctly reads normal or SSE responses. Unverified clients are not claimed as compatible.

Balance and billing

go2llm is pay-as-you-go only, with no subscription. Balances and prices are in USD. You can top up in the dashboard with cryptocurrency; funds are credited after payment confirmation. The API reserves an estimated cost before the external request, then charges actual usage and releases the remainder. The charged USD amount is returned as usage.cost_usd in a regular response or the final SSE usage block. See pricing and billing.

Per-key budget: GET /v1/me

So that an agent does not learn about an empty balance from a 402 in the middle of a long run, the remaining budget and quota can be read with the same key:

curl https://go2llm.tech/v1/me -H "Authorization: Bearer YOUR_API_KEY"

{
  "object": "api_key",
  "key": { "name": "prod", "masked": "gk_sk_abcd…wxyz", "quota_usd": 50,
           "spent_usd": 12.34, "rpm_limit": 20, "allowed_models": ["*"],
           "expires_at": null },
  "balance": { "spendable_usd": 87.66, "reserved_usd": 0.12, "currency": "USD" },
  "limits": { "account_max_concurrency": 2 }
}

Compare your cost estimate against spendable_usd: reserved_usd is money already held against in-flight requests and cannot be spent. expires_at is an ISO-8601 string or null. A key with no account returns "balance": null — its spend is bounded by the key quota alone.

The route returns no email, no other keys on the account, no referral or payment data, and never the full key secret: a leaked key must not become an identified owner or access to their other keys. Limit: 60 RPM per key, with cache-control: no-store. More detail: balance and spend.

Rate limits

The default limit is 20 RPM per API key, independently. When exceeded, the API returns HTTP 429 and Retry-After. Respect that header and use bounded exponential backoff.

Errors

Errors under /v1/ come back as a JSON envelope with error.type, error.code, error.message, and error.request_id. The x-go2llm-request-id header is present on every /v1/* response, errors included — log it. Full breakdown: API errors.

Fallback behavior

Before a response begins, the service may retry automatically after a temporary network failure, timeout, 429, or 5xx. A client-side 400 does not trigger a retry. Automatic retries stop after the first byte or valid SSE event, preventing mixed or duplicate output.

FAQ

Where do I get a model ID? Only from GET /v1/models or the dynamic table above.

Are prompts and responses stored? No. They are not stored in product logs. They are sent to the selected external AI provider to process the request.

Can one key use multiple models? Yes, when those models are allowed by the key settings.

Is there a subscription? No. go2llm uses a pay-as-you-go USD balance.

Support

Support investigates problems and errors after self-service setup. Configure integrations, SDKs, keys, and environments using the documentation.

Telegram: @go2llm_support. Email: support@go2llm.tech.

Include the time and time zone, endpoint, HTTP status, model ID, and request_id. Never send a password, session cookie, full API key, or payment credentials.