Build on Kyklos.

One OpenAI-compatible API for text, image, and video generation — with a privacy posture you can audit instead of trusting. Everything on this page works with an API key and nothing else.

#Getting started

Kyklos is a drop-in replacement for the OpenAI API. If you have working OpenAI code, changing the base URL is the whole migration.

# base URL — everything lives under /v1 /v1

Three steps: create an account, generate an API key under API keys, load credits under Billing. Billing is usage-based — credits in, generations out, one auditable ledger. No monthly minimum.

# first request curl /v1/chat/completions \ -H "Authorization: Bearer kyk_your_api_key" \ -H "Content-Type: application/json" \ -d '{ "model": "llama-3.3-70b", "messages": [{"role": "user", "content": "hello"}] }'

#Authentication

A standard bearer header. Keys start with kyk_, are shown once at creation, and are stored server-side only as a hash. Revoke any key instantly from the console.

Authorization: Bearer kyk_your_api_key

Console logins use a separate session system that can never call the inference API — a leaked session token cannot spend your credits on generations, and a leaked API key cannot change your account.

#Chat completions

POST /v1/chat/completions — the exact OpenAI shape, including streaming with "stream": true. The official OpenAI SDKs work unchanged:

# Python from openai import OpenAI client = OpenAI( base_url="/v1", api_key="kyk_your_api_key", ) r = client.chat.completions.create( model="llama-3.3-70b", messages=[{"role": "user", "content": "hello"}], ) print(r.choices[0].message.content)

// Node import OpenAI from "openai"; const client = new OpenAI({ baseURL: "/v1", apiKey: "kyk_your_api_key", }); const r = await client.chat.completions.create({ model: "llama-3.3-70b", messages: [{ role: "user", content: "hello" }], }); console.log(r.choices[0].message.content);

Text is billed per token at each model's listed input/output price. Every response includes exact token counts in usage, and the response headers carry your request id and remaining rate limit.

#Image generation

POST /v1/images/generations — OpenAI-shaped, so client.images.generate() works as-is. Billing is flat per image at the catalog price: no token meters, no surprises.

curl /v1/images/generations \ -H "Authorization: Bearer kyk_your_api_key" \ -H "Content-Type: application/json" \ -d '{ "model": "flux-2-dev", "prompt": "a lighthouse at dusk, film grain", "n": 1, "size": "1024x1024" }'

Field	Type	Notes
model	string	Any model with modality image in the catalog.
prompt	string	Up to 20,000 characters.
n	int	1–4 images. You are charged per image produced.
size	string	Optional, e.g. 1024x1024. Model default when omitted.

#Video generation

POST /v1/videos/generations — prompt in, video URL out, one flat price per clip. This endpoint is Kyklos-specific: there is no industry-standard video API yet, so we kept it as small as possible.

curl /v1/videos/generations \ -H "Authorization: Bearer kyk_your_api_key" \ -H "Content-Type: application/json" \ -d '{ "model": "fastwan-qad-fp8-1.3b", "prompt": "waves rolling onto a beach at golden hour" }' # response { "data": [{ "url": "https://…" }], "kyklos": { "cost_micro_usd": 120000 } }

Timeouts are honest Generation runs synchronously with a 110-second ceiling. A model that can't answer in time returns upstream_timeout and nothing is charged — you only ever pay for a URL you received.

#Models & pricing

The catalog is a public endpoint — anyone can audit every price without an account:

curl /v1/models

Prices are per million tokens for text, per image for image models, and per clip for video models — the response says which (input_usd_per_mtok / usd_per_image / usd_per_video). The live catalog is browsable with search and filters at /app#models.

Models never disappear silently: a removal gets a published deprecate_on date in the API at least 30 days ahead.

#Errors

Every error is { "error": { "code", "type", "request_id" } } — a code and a request id, never an echo of your request. Error bodies are a classic place prompts leak; ours structurally can't.

HTTP	Code	Meaning
400	bad_request	Malformed body or parameters.
401	unauthorized	Missing, wrong, or revoked API key.
402	insufficient_credits	Balance too low. Nothing was charged.
404	model_not_found	No such model in the catalog.
410	model_retired	Model passed its published removal date.
429	rate_limited	Over your plan's requests/minute — keyed to your account, never your IP.
503	no_route_available	Model exists but nothing healthy can serve it right now. Retryable.
502 / 504	upstream_error / upstream_timeout	The serving side failed or timed out. Nothing charged.

#Privacy architecture

Privacy at Kyklos is enforced by what the system cannot store, not by a policy PDF. The database schema has no columns for prompts, completions, IP addresses, user agents, or fingerprints; usage rows carry token counts and cost against an account id, nothing else. Rate limiting is keyed to your account — never your IP.

Tier	Status	What it means
anonymous	live	Private by policy. Requests are rebuilt field-by-field before routing, so tracking headers and metadata never reach a provider. No prompt logging anywhere in the path.
tee	hardware pilot	Served only by nodes that prove — with cryptographic attestation checked on every enrollment — that they boot the published inference image on confidential-computing hardware. Every response names the node and measurement that served it.
e2ee	hardware pilot	Your client seals the prompt to one attested node's X25519 key before it leaves your machine. The gateway relays ciphertext it cannot open and bills from the node's signed receipt.

Straight answer on the attested tiers The enrollment protocol, fail-closed routing, sealed-request format, and signed-receipt billing are built and running today. The tee and e2ee tiers go live when the first attested hardware nodes onboard — until then no model in the catalog carries those labels, because a label you can't verify is worthless.

Attestation discovery is already public API: GET /v1/models/:slug/attestation returns the ready nodes and sealing keys for any attested model, so clients can verify before sending a byte.