LazySusan API

Overview

The LazySusan API gives you 18 chat models, 13 image models and 6 video models behind one base URL and one key. Requests and responses follow the OpenAI API format, so the official OpenAI SDKs and most tools built on them work after you change the base URL and key.

You pay from a prepaid balance of credits. One credit is $0.001, so $25 buys 25,000 credits. Every request is billed for what it actually used, and requests that fail aren't charged.

Quickstart

1. Sign in and open the developer console.
2. Buy credits (packs start at $25).
3. Create a key. Copy it now: it's shown once.
4. Send your first request:

curl https://www.lazysusan.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $LAZYSUSAN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic/claude-sonnet-5-5",
    "messages": [{"role": "user", "content": "Write a haiku about lazy susans."}]
  }'

If you already use the OpenAI SDK, the only changes are base_url and api_key. The response includes usage.cost_credits, the exact amount this request cost.

Authentication

Send your key on every request as Authorization: Bearer lsk_live_…. The x-api-key: lsk_live_… header works too. Keys are lsk_live_ followed by 40 letters and digits.

• Keep keys on your server. Don't put them in browser or mobile app code, and don't commit them to git.
• Create a separate key per app or environment, so you can revoke one without breaking the others. You can have up to 20 active keys.
• Revoking a key in the console takes effect on the next request.
• We store only a one-way hash of each key, so a lost key can't be shown again. Create a new one.

Models and prices

Model ids are provider/model, for example openai/gpt-6.1-sol or google/veo-3.1-fast. Prices are in credits ($0.001 each). The same list, with every limit, is available from GET https://www.lazysusan.ai/api/v1/models (no key needed) and GET /models/{provider}/{model} for a single model.

Chat models

Priced per million tokens. Output includes any reasoning (“thinking”) tokens the model uses.

Cached input (where the provider caches a repeated prompt prefix) is billed at the lower cached rate shown in GET /models. Long prompts on some models are billed at a higher tier by the provider: Claude Haiku 5.5 above 100K input tokens, Gemini 3.1 Pro above 200K and Grok above 200K. Perplexity Sonar models run a live web search on every request; the search adds a per-request fee and search-result tokens, which are included in the request's cost_credits.

Image models

GPT Image models are billed by the tokens each image actually uses (34,500 credits per 1M image output tokens, 5,750 per 1M prompt tokens), so the figures above are typical, not fixed. Before the call, a request reserves the most an image of that size and quality could use and is charged only what it used. Larger sizes and higher quality use more tokens.

Video models

Switching models

Every model in a category takes the same request, so switching is a one-string change. No new SDK, key or billing account:

for model in ["openai/gpt-6.1-sol", "anthropic/claude-opus-5-5", "google/gemini-3.8-flash", "xai/grok-4.7"]:
    reply = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": "Summarise our refund policy in one sentence."}],
        max_tokens=400,
    )
    print(model, reply.usage.cost_credits, reply.choices[0].message.content)

Chat completions

POST https://www.lazysusan.ai/api/v1/chat/completions

Other parameters are ignored rather than rejected, so code written for other OpenAI-compatible APIs keeps working. Reasoning models (GPT-6, Gemini 3.x, Grok, DeepSeek V4 Pro, Sonar Reasoning Pro) spend part of max_tokens thinking before they answer. With a very small limit they can return an empty answer with finish_reason: "length": leave room, a few hundred tokens or more.

Response

{
  "id": "gen-6f0c2a5e-1d2b-4c7e-9a51-0b8f3c2d7e14",
  "object": "chat.completion",
  "created": 1791676800,
  "model": "anthropic/claude-sonnet-5-5",
  "choices": [
    {
      "index": 0,
      "message": { "role": "assistant", "content": "Turns once, then rests…" },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 18,
    "completion_tokens": 22,
    "total_tokens": 40,
    "cost_credits": 0.295
  }
}

usage.completion_tokens includes reasoning tokens. usage.prompt_tokens_details.cached_tokens appears when part of the prompt was cached. Perplexity models also return citations and search_results. Every response carries an x-request-id header with the same id as the body. Include it when you contact support.

Streaming

With "stream": true the response is text/event-stream. Each event is a data: line holding a chat.completion.chunk, and the stream ends with data: [DONE]. With "stream_options": {"include_usage": true}, one more chunk arrives just before [DONE], with an empty choices array and the request's usage, including cost_credits.

data: {"id":"gen-…","object":"chat.completion.chunk","model":"openai/gpt-6-luna","choices":[{"index":0,"delta":{"content":"1, 2"}}]}

data: {"id":"gen-…","object":"chat.completion.chunk","model":"openai/gpt-6-luna","choices":[{"index":0,"delta":{"content":", 3"},"finish_reason":"stop"}]}

data: {"id":"gen-…","object":"chat.completion.chunk","model":"openai/gpt-6-luna","choices":[],"usage":{"prompt_tokens":14,"completion_tokens":9,"total_tokens":23,"cost_credits":0.029}}

data: [DONE]

If you disconnect mid-stream, the request stops and you're billed for the prompt and the output generated up to that point. If a provider fails mid-stream, you'll get a final event of the form {"error": {"message", "type": "upstream_error"}} and the stream closes without [DONE].

Images in, tools and JSON

Images in a prompt

Models with “Images in: yes” accept up to 20 images per request as image_url parts. Use a public https:// URL or a base64 data:image/(png|jpeg|webp|gif);base64,… URL. detail may be low, high or auto.

client.chat.completions.create(
    model="google/gemini-3.8-flash",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "What's in this photo?"},
            {"type": "image_url", "image_url": {"url": "https://example.com/photo.jpg"}},
        ],
    }],
)

Function calling

tools = [{
    "type": "function",
    "function": {
        "name": "get_order_status",
        "description": "Look up an order by id",
        "parameters": {
            "type": "object",
            "properties": {"order_id": {"type": "string"}},
            "required": ["order_id"],
        },
    },
}]
first = client.chat.completions.create(
    model="openai/gpt-6.1-sol",
    messages=[{"role": "user", "content": "Where is order A-1042?"}],
    tools=tools,
)
call = first.choices[0].message.tool_calls[0]
# …run your function, then send the result back:
second = client.chat.completions.create(
    model="openai/gpt-6.1-sol",
    messages=[
        {"role": "user", "content": "Where is order A-1042?"},
        first.choices[0].message,
        {"role": "tool", "tool_call_id": call.id, "content": '{"status": "shipped"}'},
    ],
    tools=tools,
)

JSON output

Set response_format to {"type": "json_object"}, or json_schema with a schema, on models that support it. If a model doesn't, the provider rejects the request with a 400 and you aren't charged.

Images

POST https://www.lazysusan.ai/api/v1/images/generations

curl https://www.lazysusan.ai/api/v1/images/generations \
  -H "Authorization: Bearer $LAZYSUSAN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "google/nano-banana-2.1", "prompt": "A red ceramic cube on a white table, studio light", "size": "1344x768"}'

{
  "id": "img-2b7d…",
  "object": "image.generation",
  "created": 1791676800,
  "model": "google/nano-banana-2.1",
  "data": [{ "url": "https://…/api/…/2b7d…-0.png" }],
  "usage": { "images": 1, "cost_credits": 38.64 }
}

You're charged only for images actually delivered: if you ask for 4 and the provider returns 3, you pay for 3. If no image comes back (for example the prompt was declined by the provider's safety filter) the request returns 400 and costs nothing. Hosted URLs stay up and are unguessable; anyone with the URL can open it, so treat it like a share link. In the rare case hosting is unavailable, an item comes back as b64_json even if you asked for url.

Videos

Video takes from about a minute to a few minutes, so it runs in the background. POST https://www.lazysusan.ai/api/v1/videos returns 202 Accepted straight away with the video's id and status queued; then poll GET https://www.lazysusan.ai/api/v1/videos/{id} every 10 seconds or so until the status is succeeded or failed.

import time, requests

H = {"Authorization": f"Bearer {os.environ['LAZYSUSAN_API_KEY']}"}
job = requests.post(f"https://www.lazysusan.ai/api/v1/videos", headers=H, json={
    "model": "google/veo-3.1-fast",
    "prompt": "A slow pan across a calm lake at sunrise",
    "seconds": 8,
    "resolution": "1080p",
}).json()

while job["status"] in ("queued", "running"):
    time.sleep(10)
    job = requests.get(f"https://www.lazysusan.ai/api/v1/videos/{job['id']}", headers=H).json()

print(job["status"], job.get("video_url"), job.get("cost_credits"))

{
  "id": "vid-91c4…",
  "object": "video",
  "model": "google/veo-3.1-fast",
  "status": "succeeded",
  "created": 1791676800,
  "completed": 1791676911,
  "seconds": 8,
  "resolution": "1080p",
  "aspect_ratio": "16:9",
  "video_url": "https://…/api/…/91c4…-0.mp4",
  "cost_credits": 1104
}

• The POST response includes cost_credits_held: the video's exact price, held from your balance while it renders.
• On success you're charged that amount. On failure, the status is failed, error.message says why, and the hold is returned in full (cost_credits: 0).
• A video that hasn't finished after 2 hours is marked failed and refunded.
• Videos finish even if you stop polling; GET /videos lists your 50 most recent. The video URL is permanent and unguessable.

Credits and billing

The API runs on a prepaid balance. One credit is $0.001. Nothing is billed in arrears: a request only runs if your balance can cover it.

Buying credits

Buy packs in the console with any card.

Automatic top-up

Turn on auto top-up to never run dry: when your balance falls below a threshold you choose (1,000 to 10,000,000 credits), we charge the card you last paid with for an amount you choose ($25 to $5,000) and add the credits straight away. It needs one manual purchase first, so we have a card on file. After 3 declined charges in a row, auto top-up switches itself off.

Monthly spend limit

Set a monthly limit in credits to cap spend. When a request would take the month past it, it's refused with 402 and the code monthly_limit_reached. Credits held by requests in progress count toward the limit.

How a request is billed

1. Before a request runs, we hold the most it could cost: the full prompt plus max_tokens of output for chat, the per-image price × n for images, the clip price for video.
2. We run it, and the model reports exactly what was used.
3. You're charged for actual usage (never more than the hold), and the rest of the hold is released immediately.

Holds mean many requests can run at once without ever overdrawing your balance. A large max_tokens on an expensive model needs a bigger balance to start, even though you're only charged for what's used. Requests rejected before they reach a model, and requests the provider fails, cost nothing.

Checking your balance

curl https://www.lazysusan.ai/api/v1/credits -H "Authorization: Bearer $LAZYSUSAN_API_KEY"

{"object":"credits","balance":24183.552,"currency_per_credit_usd":0.001,"auto_top_up":false}

The console shows every request with its model, tokens and cost, plus spend this month by model.

Errors

Errors use the OpenAI shape, with an HTTP status and a machine-readable code:

{
  "error": {
    "message": "Not enough credits. This request can cost up to 62.445 credits. Add credits at https://www.lazysusan.ai/developers/console or lower max_tokens.",
    "type": "insufficient_balance",
    "code": "insufficient_balance",
    "param": null
  }
}

Responses include an x-request-id header (gen-…, img-… or vid-…) whenever a request got far enough to be billed. Send it to support if anything looks wrong.

Rate limits and limits

Over the rate limit you get 429 with a Retry-After header. Need more throughput? Write to support with your expected volume.

Data and security

• All traffic is HTTPS. Keys are stored only as one-way hashes.
• We don't store your prompts or the text models send back. We keep a usage record per request (model, token counts, cost, time) for billing and your console.
• Generated images and videos are hosted at unguessable URLs so you can use them directly. Download and re-host them if you need to control access.
• Image URLs you send us are fetched only from the public internet; private and internal addresses are refused.
• Requests are processed by the model's provider under that provider's API terms.

Changelog

Support

Email support@lazysusan.ai with your request id. For volume pricing, invoicing or a higher rate limit, say so in the subject .