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:
    if chunk.choices:
        print(chunk.choices[0].delta.content or "", end="")

Streaming uses the same billing rules as a non-streaming request. Token-billed models include provider-reported input, output and reasoning usage; usage is not the dollar charge. See Billing and limits and the usage history for the final charge.

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…

Current billing rules are loading. Check the model price before sending.

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. If free models are offered, they are not charged and are limited by number of calls. For paid models 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

Current billing rules are loading. Check the model price before sending.

Each model's price is on the Pricing page

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,
    "reservation": true,
    "message": "Insufficient balance: the reservation ceiling for this request is $0.025 and your available balance is $0.01. Top up or reduce the request size and output limit."
  }
}

FAQ