Your tools. One API key.

Leaked keys

When one of your keys appears in a public GitHub repository, GitHub notifies us within seconds and the key is disabled straight away. An email then goes to the address on your account, naming the key and where it was found.

A disabled key stops working immediately: any request still carrying it is answered with 401 unauthorized. Your account, your balance and your other keys are unaffected.

What to do next

1. Create a replacement key in the console and put it into your application.
2. Remove the old key from your code. Deleting the line is not enough: the key remains in the repository history, so rewrite the history, or treat that key as permanently public.
3. Keep keys out of source code altogether. Read them from an environment variable or a secrets manager, and list the file holding them in .gitignore.

If you notice a leak yourself

Disable the key yourself in the console — it takes effect at once — then create a replacement. If you suspect someone else has used it, contact us and we will go through that key's request history with you.

Streaming

Set stream to true and you get server-sent events, same format as the OpenAI API. Every official client handles this out of the box.

from openai import OpenAI

client = OpenAI(api_key="YOUR_API_KEY", base_url="/v1")
stream = client.chat.completions.create(
    model="MODEL_ID",
    messages=[{"role": "user", "content": "Hello!"}],
    stream=True,
)
for chunk in stream:
    print(chunk.choices[0].delta.content or "", end="")

Billing works the same way on a stream: the final chunk carries the usage count, computed from the text you sent and the text you received; on big models the charge is worked out from it, and free models are not charged.

Images

Models that read images take pictures inside a user message: put the text and each image as parts of content, each image as a base64 data URL.

{
  "model": "MODEL_ID",
  "messages": [{
    "role": "user",
    "content": [
      { "type": "text", "text": "What is in this picture?" },
      { "type": "image_url",
        "image_url": { "url": "data:image/jpeg;base64,/9j/4AAQ..." } }
    ]
  }]
}

Models that read images right now: Loading the list…

On big models each image costs a fixed amount on every request that carries it, on top of the text; free models charge nothing for images. A request may carry at most 8 images; each must be PNG, JPEG, WebP or GIF and at most 3 MB. An image sent to a model that cannot read it is refused with model_no_vision, and nothing is charged. Images are passed to the model provider for the answer and are not stored on this site.

Other endpoints

The same key works on the endpoints below, so a tool built for another provider's request format can be pointed at this site as well. Each is called with POST, and the key goes in the Authorization header as Bearer unless a row says otherwise.

Videos

POST /v1/videos makes a short video with sound from one sentence. The request body is JSON with these fields:

curl "/v1/videos" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "MODEL_ID",
    "prompt": "A lighthouse on a cliff at dusk, waves breaking below",
    "seconds": 5,
    "size": "1280x720"
  }'

The reply comes at once. It carries the video's id, status in_progress and progress 0:

{
  "id": "video_abc123",
  "object": "video",
  "model": "MODEL_ID",
  "status": "in_progress",
  "progress": 0,
  "created_at": 1760500000,
  "seconds": 5,
  "size": "1280x720"
}

Ask GET /v1/videos/{id} until status is completed, when the reply also carries url and completed_at, or failed, when it carries error with code and message. A video usually takes one to two minutes. GET /v1/videos/{id}/content downloads the MP4 file.

curl "/v1/videos/video_abc123" \
  -H "Authorization: Bearer YOUR_API_KEY"

curl -L "/v1/videos/video_abc123/content" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -o video.mp4

A video is charged to the balance by the second, at the price of its resolution, only once it has been made; a video that fails is not charged. The models and their prices right now:

Models

These are the models you can call right now. Free models are not charged and are limited by number of calls. For the others the cost column is measured, not promised: a 30-day average of what one answer cost, in dollars, so a long answer costs more and a short one less.

Models are served through independent third-party providers but use the same request shape, so switching models only changes one string in your code. The list can change without notice: read it from the models endpoint at runtime rather than hard-coding names.

The same list, with who made each model, is on the Models page. To list them from code, call the models endpoint with your key:

curl "/v1/models" \
  -H "Authorization: Bearer YOUR_API_KEY"

Billing and limits

The balance is counted in US dollars and comes only from top-ups: the amount you pay is your balance, and it never expires. Claude, GPT and other big models are charged to it by usage, worked out from the visible text sent and received; the DeepSeek coding line is charged at what DeepSeek billed for the call. Free models are not charged; they are limited by number of calls, and a longer message counts as several calls. Length is counted over everything the request sends, the earlier conversation, the persona and file text included: each Chinese character counts 1 and every 4 other characters (letters, digits, spaces, punctuation) count 1, and each 50,000 counted, or part of it, is one call. The first time a single API request to a charged model would cost a large amount, the site does not run it: it answers with an ordinary reply stating the estimated cost, and nothing is charged. Sending the same request again runs it as usual. Requests of that size are not announced again; the notice comes once more only when a single request would cost ten times as much.

Each model's price is on the Pricing page, where you can also top up.

Check your balance any time from the My account page, or from code. The reply gives balance in the site's internal unit; divide it by money.unitsPerUsd from GET /api/info to get dollars:

curl "/api/me" \
  -H "Authorization: Bearer YOUR_API_KEY"

Errors

Every failure comes back as JSON with a stable code field. Match on the code, not on the message text, which is written for humans and may change. Amounts in an error body are in the site's internal unit; where a body carries need or balance, it also carries needUsd or balanceUsd, the same amount in dollars. When sending the same request again would fail the same way (a bad key, an insufficient balance, a used-up quota), the response also carries the x-should-retry: false header; only 408, 409, 429 and 5xx are worth retrying. Tools that resend every refusal (Codex, omp, or any streaming request sent again unchanged within seconds of a refusal) receive the refusal as an ordinary reply that states the reason, so that they stop.

{
  "error": {
    "code": "not_enough_credit",
    "balance": 6000,
    "balanceUsd": 0.01,
    "need": 15000,
    "needUsd": 0.025,
    "message": "Insufficient balance: this request needs about $0.025 and your balance is $0.01. Top up, or switch to a free model."
  }
}

FAQ