LLM & Image API

Overview

GPUniq provides a single API surface for 90+ language models and image generators across Anthropic, OpenAI, Google, xAI, and DeepSeek. One API key, one balance, one usage dashboard — chat completions, reasoning, and text-to-image all in the same place.

You can use GPUniq LLMs two ways:

1. Native GPUniq API (/v1/llm/*) — wrapped responses, persistent chat sessions, terminal-command generator, SDK helpers.
2. OpenAI-compatible API (/v1/openai/*) — drop-in replacement for api.openai.com/v1. Works with Claude Code, Cursor, Continue.dev, Aider, LiteLLM, and the official OpenAI Python/JS SDKs without code changes.

Available Models

Chat & Reasoning

DeepSeek pricing (USD per 1M tokens, already discounted −20%)

DeepSeek V4 — priced live, not from a table

deepseek-v4-pro and deepseek-v4-flash are open-weight, so they sit in the open-weight tier: the price is not a fixed catalog number but the cheapest live rate available for those weights, plus our margin. It moves as the market moves, which is why it is deliberately absent from the table above — any number printed here would be stale within days.

Read the live figure from GET /v1/llm/models, or the model card in /chat. As of 2026-08-16 that resolves to roughly $0.52 / $1.04 for deepseek-v4-pro and $0.09 / $0.18 for deepseek-v4-flash per 1M tokens — in both cases at or below what DeepSeek's own API charges for the same model.

MiniMax pricing (USD per 1M tokens)

Image Generation

Image models are billed per returned image, not per token.

How size picks the GPT Image 2 tier (and the price). The size field accepts WIDTHxHEIGHT or a bare 1k / 2k / 4k. The tier is chosen by a ceiling rule on the long side — the delivered image is never smaller than the ask: up to 1024px → base gpt-image-2 ($0.0464), up to 2048px → the 2K tier ($0.07), above 2048px → the 4K tier ($0.11). The response's usage.model (sync) / model (job) names the tier you were billed for, and the kickoff's estimated_cost_usd reflects it up front. Aspect ratio follows your size proportions — wide and tall formats including 21:9 and 3:2 are honoured, with or without reference images.

Nano Banana Pro upgrades by pixel budget, not by long side — banana tiers scale output with the aspect ratio (the 2K tier at 16:9 renders 2752×1536), so a QHD 2560x1440 ask stays on the base Pro ($0.1072) and comes back at 2752×1536. Only asks beyond the 2K budget (more than ~4.2 MP, or wider than 3168px) auto-upgrade to nano-banana-pro-4k ($0.192).

GPT Image 2 2K/4K renders now return the exact width×height you asked for (up to a 3840px long side; larger asks scale down proportionally, e.g. 4096×4096 → 3840×3840) and typically complete in 40–80 seconds. If the primary route rejects a request, GPUniq retries on an alternate 2K/4K route automatically; if the content itself is rejected everywhere, the request degrades once to the base gpt-image-2 at the base price ($0.0464, ~1.6K render) — the response's model field always names the SKU you were billed for.

Nano Banana 4K output dimensions depend on the aspect ratio — the tier fixes the pixel budget, not the long side, so wide formats come back wider than 4096px. Expect these dimensions from the 4K tier (nano-banana-pro-4k, nano-banana-2 at 4K):

4K renders on this family take noticeably longer than 1K/2K — 2–5 minutes is normal, which is another reason to keep the job polling budget at 10 minutes.

# 403, error code 1010 — blocked at the edge, never reaches the API
urllib.request.urlopen(urllib.request.Request(url, data=body))

# Works — requests sends its own User-Agent
requests.post(url, json=payload, headers={"X-API-Key": KEY})

# Works — urllib with an explicit User-Agent
req = urllib.request.Request(url, data=body, headers={
    "X-API-Key": KEY,
    "Content-Type": "application/json",
    "User-Agent": "my-app/1.0",     # <- the one line that matters
})

Job-based image generation (recommended)

POST /v1/llm/images/jobs returns a job_id in under a second, and you poll GET /v1/llm/images/jobs/{job_id} every 2-3 seconds until the status is terminal. You are charged only when the completion poll returns — a timed-out or failed job costs nothing. Server-side, polls that arrive within 2 seconds of each other are coalesced via Redis, so hammering the endpoint will not be billed as repeated upstream calls.

A status: "failed" payload carries a typed error_code — content_moderation (the input was rejected by the upstream content policy; rephrase, don't retry verbatim) or generation_failed (transient; re-kick off). Give the poll loop a 10-minute budget: moderation verdicts and internal retries can land several minutes after kickoff, and abandoning early costs you the render you would have received. Handling recipes: Errors → Image jobs.

import time, requests

BASE = "https://api.gpuniq.com/v1/llm"
HEADERS = {"X-API-Key": "gpuniq_your_key"}

# 1. Kickoff
start = requests.post(
    f"{BASE}/images/jobs",
    headers=HEADERS,
    json={"model": "nano-banana-pro", "prompt": "a cozy cabin at sunrise", "n": 1},
).json()
job_id = start["data"]["job_id"]

# 2. Poll — 10-minute budget: slow 4K renders, moderation verdicts and
#    internal retries can all land several minutes after kickoff
deadline = time.time() + 600
while time.time() < deadline:
    time.sleep(2.5)
    r = requests.get(f"{BASE}/images/jobs/{job_id}", headers=HEADERS).json()
    d = r["data"]
    if d["status"] == "completed":
        image_b64 = d["image"]["b64_json"]
        print(f"Cost: ${d['cost_usd']}, balance: ${d['balance_usd']}")
        break
    if d["status"] == "failed":
        if d.get("error_code") == "content_moderation":
            # Content-policy verdict — retrying the same prompt will fail
            # again. Rephrase (drop video-style wording: durations,
            # camera moves) and kick off a new job.
            print("rejected by content policy:", d.get("error"))
        else:
            # generation_failed — transient; safe to re-kick off.
            print("failed:", d.get("error"))
        break

Which endpoint serves which slug

Every image slug in the catalog works on the job API. There is no subset to memorise and no reason to keep a synchronous code path around: if the model is in the table above, POST /v1/llm/images/jobs accepts it.

n must be 1 — issue separate jobs in parallel for batches. (Topaz upscaling/enhancement has its own dedicated job surface — see the Topaz guide.)

Behind the job id there are two execution modes, and the difference is not visible in the API contract — same kickoff, same polling, same response shape:

The second mode runs the same multi-tier provider cascade the synchronous endpoint uses, so failover, moderation verdicts and format conversion all behave identically. You are still charged only on delivery.

Video has no synchronous endpoint at all. Every video generation goes through POST /v1/llm/videos/jobs — there is nothing to migrate and no sync variant to find.

Generating an image inside a chat session

When you want the image to appear as a turn in an existing chat (so the prompt and result both land in the chat history), POST to /v1/llm/chats/{chat_id}/messages with an image model. The response returns immediately with type: "image_pending" plus a job_id and the dialogue_id of a placeholder row that already lives in the chat history. Poll GET /v1/llm/chats/{chat_id}/image-jobs/{job_id} until the status is completed (placeholder is rewritten with the image and the balance is debited) or failed (placeholder is marked, nothing charged). The polling endpoint 404s once the job is terminal — the final dialogue is the source of truth from then on.

import time, requests

BASE = "https://api.gpuniq.com/v1/llm"
HEADERS = {"X-API-Key": "gpuniq_your_key"}
chat_id = 42  # existing chat created via POST /v1/llm/chats

# 1. Kickoff (POST /chats/{id}/messages with an image model)
start = requests.post(
    f"{BASE}/chats/{chat_id}/messages",
    headers=HEADERS,
    json={"model": "nano-banana-pro", "message": "a cozy cabin at sunrise"},
).json()
job_id = start["data"]["job_id"]
dialogue_id = start["data"]["dialogue_id"]

# 2. Poll — same 5-minute budget as the standalone /images/jobs flow
deadline = time.time() + 300
while time.time() < deadline:
    time.sleep(2.5)
    r = requests.get(
        f"{BASE}/chats/{chat_id}/image-jobs/{job_id}", headers=HEADERS,
    ).json()
    d = r["data"]
    if d["status"] == "completed":
        image_b64 = d["image"]["b64_json"]
        print(f"Cost: ${d['cost_usd']}, balance: ${d['balance_usd']}")
        break
    if d["status"] == "failed":
        print("failed:", d.get("error"))
        break

Use this surface when the image should be part of a multi-turn conversation. Use the standalone /images/jobs surface when you don't need persistence — it has the same job semantics without creating a chat row.

Video Generation

Video models are billed per delivered video, not per token. Every generation is asynchronous — POST to /v1/llm/videos/jobs to kick off a job, then poll GET /v1/llm/videos/jobs/{job_id} until the status is terminal. You are charged only when the completion poll returns a video.url — a failed or timed-out job costs nothing.

Veo 3.1 (Google)

All three Veo tiers are billed per video, by resolution. Duration can be 4, 6 or 8 seconds (default 8) and does not change the price.

• First + last frame — image_url (first frame) + last_frame_url (last frame) on all three tiers; the clip interpolates between the two frames and the order is honoured.
• Reference-to-video — up to 3 reference images via reference_image_urls on veo-3-1-fast / veo-3-1-lite (8-second clips only; not available on Quality). Mutually exclusive with last_frame_url.
• aspect_ratio: 16:9 (default), 9:16, or auto (follows the input image geometry).
• On a provider fallback the charge follows the serving upstream's rate — the exact amount is always in the completion cost_usd.

Kling O3

Kling O3 is billed per second, by resolution and audio flag, for clips of 3–15 seconds (default 5). Prompts are capped at 2500 characters.

• Text-to-video — prompt only; aspect_ratio is 16:9 (default), 9:16 or 1:1.
• Image-to-video — image_url (start frame), optionally with last_frame_url (end frame). The aspect ratio follows the frame.
• Reference-to-video — up to 4 reference images via reference_image_urls, which define the subject/style. image_url / last_frame_url may ride along as start / end anchors.
• No reference video. video_url / video_urls are rejected with a 400 on this model: the upstream accepts a clip at submit and then fails the render. For video-to-video use kling-2-6-motion-control / kling-3-0-motion-control.

Seedance (ByteDance)

Seedance is ByteDance's text-to-video / image-to-video family — fast, photoreal 720p clips, well suited to product shots, social content, and image-to-video animation of a still frame. Three SKUs are in the catalog, and they do not all price the same way, so read this before budgeting a batch.

Choosing between them:

• seedance-1-5-pro — cheapest ($0.160/clip), newest of the "pro" tier. Best default for short 720p clips where you want a fixed, predictable price.
• seedance-1-0-pro — the previous pro model ($0.210/clip); keep using it only if you've tuned prompts against it.
• seedance-2 — the flagship quality tier. Priced per second, so it scales with clip length — reach for it when quality matters more than cost, and keep durations short to control spend.

Text-to-video (default) needs only a prompt. Image-to-video animates a still: pass image_url (an https URL or data: URI) as the start frame. All three Seedance SKUs support both.

import time, requests

BASE = "https://api.gpuniq.com/v1/llm"
HEADERS = {"X-API-Key": "gpuniq_your_key"}

# Image-to-video with the flagship, 6-second clip
start = requests.post(
    f"{BASE}/videos/jobs",
    headers=HEADERS,
    json={
        "model": "seedance-2",
        "prompt": "the product slowly rotates on a marble pedestal, soft studio light",
        "image_url": "https://example.com/product.jpg",  # start frame → image-to-video
        "duration": 6,          # seedance-2 bills per second → 6 × $0.33 = $1.98
    },
).json()["data"]
job_id = start["job_id"]
print("estimated:", start["estimated_cost_usd"])   # 1.98

deadline = time.time() + 300
while time.time() < deadline:
    time.sleep(3)
    d = requests.get(f"{BASE}/videos/jobs/{job_id}", headers=HEADERS).json()["data"]
    if d["status"] == "completed":
        print("video:", d["video"]["url"], "cost:", d["cost_usd"])
        break
    if d["status"] == "failed":
        print("failed:", d.get("error"))
        break

Seedance shares the standard video job API. The two -pro SKUs (seedance-1-0-pro, seedance-1-5-pro) do text-to-video and image-to-video only: duration and image_url are the fields that matter, aspect_ratio is honoured where the upstream supports it, and fields specific to other families (audio, mode, resolution tiers, video_url) are ignored.

seedance-2 accepts more of the request body. On top of t2v and i2v it supports:

• First + last frame — pass image_url (start) together with last_frame_url (end); the clip interpolates between the two frames.
• Reference-to-video — condition the render on up to 3 reference clips (video_url / video_urls), up to 9 reference images (reference_image_urls) and up to 3 reference audio tracks (audio_url / audio_urls), in any combination. Audio references need at least one image or video reference alongside them (the API returns a 400 otherwise). A single image_url sent together with any reference input is treated as a subject reference rather than a start frame. First/last-frame and reference-to-video are mutually exclusive — when any reference input is attached, last_frame_url is dropped.
• Resolution choice — 480p, 720p (default), 1080p or 4k via resolution; the per-second price scales with it (see the pricing table above).
• Generated audio track — set audio: true to have the model generate sound for the clip.

duration applies to all three SKUs (seedance-2 accepts 4–15 seconds); seedance-2 is billed per second regardless of which mode you use. On seedance-2, aspect_ratio additionally accepts auto, 21:9, 4:3 and 3:4 — omit it in i2v mode to follow the input frame's geometry.

seedance-2 also accepts a seed. Be aware of what it actually buys: keeping the seed fixed while everything else stays identical makes two renders markedly more alike than two unseeded ones, but they will not be identical — the model is not bit-reproducible, so treat the seed as a similarity control rather than a repeat button. A seeded request is routed to the one upstream that implements the parameter; if that route is unavailable the clip is still rendered, without the seed.

Reference-file limits: videos 2–15s combined, ≤50MB total; images JPG/PNG/WebP; audio MP3/WAV, ≤15s combined. Video resolution and container are unrestricted — 1080p/4K clips and non-MP4 formats (webm, MKV, …) are automatically converted to ≤720p MP4 on our side before dispatch, so send your source footage as-is.

Job-based video generation

Same kickoff-then-poll shape as the image-jobs API. The catalog covers text-to-video (t2v), image-to-video (i2v, pass image_url), and video-to-video / motion-control (v2v, pass video_url + image_url for the conditioning frame). Avatar SKUs accept an audio reference URL in the prompt body — see the model-specific docs for the schema.

import time, requests

BASE = "https://api.gpuniq.com/v1/llm"
HEADERS = {"X-API-Key": "gpuniq_your_key"}

# 1. Kickoff
start = requests.post(
    f"{BASE}/videos/jobs",
    headers=HEADERS,
    json={
        "model": "kling-2-6",
        "prompt": "A small black cat slowly turns toward the camera at golden hour",
        "duration": 5,
        "audio": False,          # opt-in, doubles price on Kling 2.6 / 3.0
        "resolution": "1080p",   # 720p | 1080p | 4k (where supported)
    },
).json()
job_id = start["data"]["job_id"]
print(f"job: {job_id}, est cost: ${start['data']['estimated_cost_usd']}")

# 2. Poll — video models deliver in 30-90s; budget 5 minutes for the slowest variants
deadline = time.time() + 300
while time.time() < deadline:
    time.sleep(3)
    r = requests.get(f"{BASE}/videos/jobs/{job_id}", headers=HEADERS).json()
    d = r["data"]
    if d["status"] == "completed":
        print(f"video: {d['video']['url']}")
        print(f"cost: ${d['cost_usd']}, balance: ${d['balance_usd']}")
        break
    if d["status"] == "failed":
        print("failed:", d.get("error"))
        break

Request body

Duration by model

duration is not a free integer. Each family accepts its own set and anything outside it comes back as a 400 naming the legal values — we do not round to the nearest supported length, because silently rendering (and billing) 8 seconds when you asked for 5 is worse than a refusal.

Reference media: what format to send

Every media field takes a URL string, never an uploaded file part — there is no multipart endpoint. Two forms are accepted:

Upstream renderers only accept URLs, so a data: URI on a video or audio field is materialised into a real link on our side before dispatch. You do not have to host anything yourself to use a reference clip.

Hosted links are re-hosted when the host misdescribes them. Upstream validators judge a reference clip by the Content-Type the host declares, not by the bytes — so a perfectly good MP4 served as application/octet-stream used to be refused on sight. GPUniq now probes that header and, when it is not a video/* type, fetches the file and re-serves it correctly before dispatch.

Serving a reference from a bucket with the right Content-Type is still the fastest path: it skips the extra fetch entirely. What the upstream fetch requires, in the order things usually go wrong:

1. A direct link to the file, not to a viewer page. The response must be the bytes themselves.
2. No authentication, no redirect chain to a login page. The fetcher is anonymous and has no cookies.
3. A media Content-Type — video/mp4, image/jpeg, audio/mpeg. Handled for you when it is wrong, at the cost of one extra round trip.
4. A file extension that matches the content where possible — some upstreams sniff the URL path before they sniff the body.

Size and format limits:

Reference video resolution and container are unrestricted: 1080p/4K and non-MP4 sources are transcoded to ≤720p MP4 on our side before dispatch, so send source footage as-is. Keep in mind that a data URI inflates by ~33% over the raw bytes and counts against the request body limit — for anything above a few MB, host it and send a URL.

Which model takes which reference input

Sending a field the chosen model has no input for is a 400 at submit, not a silent drop. That is deliberate: previously a request carrying reference_image_urls could render on one attempt and be refused on the next, depending on which internal route served it. Capability is now resolved before dispatch, so the same request gets the same answer every time.

For subject or style reference on a model with no reference_image_urls column, use image_url as the start frame — or move to seedance-2, which has the widest reference surface in the catalog.

Motion control is the strictest shape here: kling-2-6-motion-control and kling-3-0-motion-control need both image_url (the character / subject frame) and video_url (the motion to transfer). Either one alone is a 400 naming the missing field.

Response

The kickoff returns immediately with the GPUniq job id, the resolved parameter snapshot, and the cost estimate. Internal routing is opaque — the same job_id is valid across fallbacks, and the user-facing price stays stable.

// POST /v1/llm/videos/jobs
{
  "job_id": "vid_e93e98c7ca5e4982876b",
  "status": "pending",
  "model": "kling-2-6",
  "estimated_cost_usd": 0.315,
  "config": { "resolution": "1080p", "audio": false, "duration": 5, "task": "t2v", "mode": null }
}

// GET /v1/llm/videos/jobs/{job_id} — completed
{
  "job_id": "vid_e93e98c7ca5e4982876b",
  "status": "completed",
  "model": "kling-2-6",
  "video": {
    "url": "https://cdn.example.com/.../output.mp4",
    "stored_url": "https://api.gpuniq.com/v1/llm/media/8xK2p….mp4",
    "stored_expires_in_days": 7
  },
  "cost_usd": 0.315,
  "balance_usd": 9.17825791,
  "config": { "resolution": "1080p", "audio": false, "duration": 5, "task": "t2v", "mode": null }
}

The polling endpoint transparently falls back across internal routes if the first attempt fails — your job_id and the user-facing price stay stable across fallbacks. Internal route identifiers are deliberately omitted from the public response; they live only in admin/operator logs.

Where delivered media lives

Every generated image and video is also mirrored to GPUniq storage, and the response tells you where:

Why it matters: the upstream video.url points at the rendering provider's CDN, and its lifetime is set by them, not by us. If you store that link rather than the bytes, it can stop resolving well before you expect. stored_url is ours and lives exactly as long as the field says.

Two practical notes. For images the copy is written before the response is sent, so url works the moment you receive it. For videos the copy runs in the background — a clip is tens of megabytes and we would rather not make the delivering poll wait on it — so stored_url becomes valid shortly after the response; url is live immediately either way. And if storage is briefly unavailable the stored_url / url fields are simply absent: the generation still succeeds and is still delivered, because a storage hiccup is never allowed to fail a render you paid for.

Upscaling & Enhancement (Topaz)

Topaz Labs restoration engines — the models behind Gigapixel AI and Video AI — run on a dedicated job surface. No prompt: send a source, pick a model, get the enhanced result back.

Topaz is billed differently from the generative media above. It is a restoration API metered in credits, so instead of a flat per-image rate the cost scales with output size and is charged at $0.14 per credit (≈1 credit per 24 MP of output for precision models — a 4K upscale is about $0.14). You pay only when the job completes.

See the Topaz upscaling guide for the full model catalog, parameters, credit-pricing table, and end-to-end examples.

Chat models are sold at 20% below vendor list price.

Fetch the live catalog at any time:

models = client.llm.models()
for model in models["models"]:
    print(model)

curl https://api.gpuniq.com/v1/llm/models/catalog

curl https://api.gpuniq.com/v1/openai/models \
  -H "Authorization: Bearer gpuniq_your_key"

The default model is claude-haiku-4-5 — fast, cheap, strong at code.

Long generations & streaming

The edge proxy closes inbound connections after ~100 seconds of streaming silence. A non-streaming request asking for max_tokens > 4096 is rejected up-front with HTTP 400 streaming_required — buffered responses past that length routinely lose to the cap. For long replies, set "stream": true or use the job-based long-poll API.

Reasoning models (Gemini 3 Pro, DeepSeek R1, o3, Claude Opus thinking) burn tokens on hidden chain-of-thought before the visible reply, so they need extra max_tokens headroom — see the Long generations guide for the full streaming / job-based / reasoning-token recipe.

Errors

Every failure returns a stable OpenAI error envelope with a structured code you can branch on — streaming_required, insufficient_balance, model_not_found, rate_limit_per_key, etc. See the Error reference for the complete catalog (29 codes), recovery strategies, and the native vs. OpenAI-compat envelope shapes.

{
  "error": {
    "message": "…human-readable description…",
    "type": "invalid_request_error",
    "code": "streaming_required",
    "doc_url": "https://docs.gpuniq.com/llm/long-generations",
    "meta": { "max_tokens": 8000, "limit": 4096 }
  },
  "status_code": 400,
  "request_id": "…"
}

OpenAI-Compatible Endpoint

Point any OpenAI-compatible tool at GPUniq by setting two environment variables:

OPENAI_API_KEY=gpuniq_your_key
OPENAI_BASE_URL=https://api.gpuniq.com/v1/openai

Every field of the OpenAI Chat Completions protocol is forwarded unchanged: tools, tool_choice, response_format, logprobs, seed, stream, stream_options, etc.

Official OpenAI SDK

from openai import OpenAI

client = OpenAI(
    api_key="gpuniq_your_key",
    base_url="https://api.gpuniq.com/v1/openai",
)

resp = client.chat.completions.create(
    model="claude-opus-4-7",
    messages=[{"role": "user", "content": "Write a binary search in Rust."}],
)
print(resp.choices[0].message.content)

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "gpuniq_your_key",
  baseURL: "https://api.gpuniq.com/v1/openai",
});

const resp = await client.chat.completions.create({
  model: "claude-opus-4-7",
  messages: [{ role: "user", content: "Write a binary search in Rust." }],
});
console.log(resp.choices[0].message.content);

curl https://api.gpuniq.com/v1/openai/chat/completions \
  -H "Authorization: Bearer gpuniq_your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-4-7",
    "messages": [{"role": "user", "content": "Write a binary search in Rust."}]
  }'

Streaming

Set stream: true — GPUniq returns a text/event-stream with byte-identical OpenAI SSE framing:

stream = client.chat.completions.create(
    model="gpt-5.2",
    messages=[{"role": "user", "content": "Explain MoE in one paragraph."}],
    stream=True,
)
for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="", flush=True)

Image Generation

Both API surfaces expose a /images/generations endpoint that matches OpenAI's images.generate protocol. Pass any image slug from the catalog above (e.g. nano-banana-pro, gpt-image-2, flux-2-pro, seedream-4). Billing is flat per returned image — no token accounting.

Image requests route through a multi-tier reliability chain behind the scenes: a per-model priority gateway, two cost-optimised intermediaries, then a generic OpenAI-compatible fallback for safety. The chain is selected automatically per slug, so SDK callers never pick a backend themselves. If the primary fails or returns no image, the next tier is tried within the same HTTP request — you still see one synchronous POST /images/generations and pay for delivered images only.

Heavy generations (Pro / 4K, multi-image batches, high-quality preset) can run up to 5 minutes end-to-end; the connection is held open for that whole budget so SDKs never need to re-poll.

from openai import OpenAI

client = OpenAI(
    api_key="gpuniq_your_key",
    base_url="https://api.gpuniq.com/v1/openai",
)

resp = client.images.generate(
    model="nano-banana-pro",
    prompt="A cozy mountain cabin at sunrise, cinematic lighting",
    n=2,
    size="1024x1024",
    response_format="b64_json",
)

for i, img in enumerate(resp.data):
    with open(f"out_{i}.png", "wb") as f:
        import base64
        f.write(base64.b64decode(img.b64_json))

import base64, requests

with open("reference.jpg", "rb") as fh:
    ref = "data:image/jpeg;base64," + base64.b64encode(fh.read()).decode()

resp = requests.post(
    "https://api.gpuniq.com/v1/llm/images/generations",
    headers={"X-API-Key": "gpuniq_your_key"},
    json={
        "model": "nano-banana-pro",
        "prompt": "Redraw the cabin in watercolor style",
        "n": 1,
        "size": "2048x2048",
        "input_images": [ref],
    },
).json()

print("cost:", resp["data"]["cost_usd"])

curl -X POST https://api.gpuniq.com/v1/openai/images/generations \
  -H "Authorization: Bearer gpuniq_your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-4-image",
    "prompt": "Studio portrait of an astronaut in a pink desert",
    "n": 1,
    "size": "1024x1024"
  }'

Parameters

Claude Code

Claude Code talks to GPUniq directly — GPUniq exposes a native Anthropic Messages API at /v1/messages, so no LiteLLM (or any other) proxy is required. Point Claude Code's environment variables straight at GPUniq:

export ANTHROPIC_BASE_URL=https://api.gpuniq.com
export ANTHROPIC_API_KEY=gpuniq_your_key
export ANTHROPIC_MODEL=claude-opus-4-7              # main model
export ANTHROPIC_SMALL_FAST_MODEL=claude-haiku-4-5  # background/small model
claude

Use any Claude slug from /v1/openai/models for the two model variables. Streaming and tool use work out of the box. All tokens are billed against your GPUniq balance — no separate Anthropic account required.

Cursor

Settings → Models → Override OpenAI Base URL:

Base URL:  https://api.gpuniq.com/v1/openai
API Key:   gpuniq_your_key
Model:     claude-opus-4-7   # or any slug from /v1/openai/models

Continue.dev / Aider / LiteLLM

Any tool that accepts an OPENAI_BASE_URL works the same way:

export OPENAI_API_KEY=gpuniq_your_key
export OPENAI_BASE_URL=https://api.gpuniq.com/v1/openai

aider --model claude-sonnet-4-6

Native GPUniq SDK

For the fullest feature set — persistent chat sessions, USD balance conversion, usage history — use the native API.

Simple Chat

response = client.llm.chat("claude-haiku-4-5", "Explain how transformers work")
print(response)

curl -X POST "https://api.gpuniq.com/v1/llm/chat/completions" \
  -H "X-API-Key: gpuniq_your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [{"role": "user", "content": "Explain how transformers work"}],
    "model": "claude-haiku-4-5"
  }'

Chat Completion (Full)

data = client.llm.chat_completion(
    messages=[
        {"role": "system", "content": "You are a helpful AI assistant."},
        {"role": "user", "content": "What is gradient descent?"},
    ],
    model="claude-sonnet-4-6",
    temperature=0.7,
    max_tokens=1000,
    top_p=0.9,
)

print(data["content"])
print(f"Tokens used: {data['tokens_used']}  cost: ${data['cost_usd']:.6f}")

Parameters

Account Balance

Chat and image requests are billed directly against your GPUniq account balance in USD — there is no separate "token pool" anymore. Each call deducts the model's blended retail rate × the tokens it actually consumed (or per-image flat rate for image models). Prepaid token packages and ruble-to-token conversions are no longer required and the corresponding endpoints have been retired.

balance = client.llm.balance()
print(f"Available: ${balance['balance_usd']:.4f} USD")

curl https://api.gpuniq.com/v1/llm/balance \
  -H "Authorization: Bearer gpuniq_your_key"

Top up the balance from the web dashboard → Billing (Stripe / YooKassa / crypto). The balance is shared with every other GPUniq surface — GPU rentals, volume storage, image generations — so a single deposit covers the whole platform.

Usage History

Per-request detail with prompt / completion / cached / reasoning tokens and the USD cost charged at retail. Backed by the /v1/llm/usage/history endpoint; pair it with /v1/llm/usage/breakdown for daily / weekly aggregates.

history = client.llm.usage_history(limit=50, offset=0)
for log in history["logs"]:
    print(f"{log['model']}: {log['total_tokens']} tokens — ${log['cost_usd']:.6f}")

Chat Sessions

Persistent conversations stored server-side — the model sees the full history on every call:

# Create a session
session = client.llm.create_chat_session(
    model="claude-sonnet-4-6",
    title="Research Assistant",
)

# Send messages within the session
reply = client.llm.send_message(
    chat_id=session["id"],
    message="What are the key papers on attention mechanisms?",
    temperature=0.5,
)

# List all sessions
sessions = client.llm.list_chat_sessions(limit=50)

# Get a session with full message history
full = client.llm.get_chat_session(chat_id=session["id"])

# Update title
client.llm.update_chat_session(chat_id=session["id"], title="New Title")

# Delete
client.llm.delete_chat_session(chat_id=session["id"])

Generate Terminal Commands

Convert natural language to a ranked list of shell commands with danger annotations:

cmds = client.llm.generate_commands(
    prompt="find all Python files larger than 1MB and sort by size",
    max_commands=5,
)
for c in cmds["commands"]:
    print(f"[{c['danger']}] {c['command']}  # {c['description']}")

API Key Management

API keys are created from the web dashboard (LLM API Keys) and sent as Authorization: Bearer gpuniq_... on OpenAI-compat routes, or X-API-Key: gpuniq_... on native routes.

Rate limit: 120 req/min per key, sliding window.