Build with fast, metered model access.

Quickstart

Send a standard OpenAI-style request with a Starveri API key. The API accepts Bearer authentication and returns OpenAI-compatible JSON or SSE.

curl https://api.starveri.net/v1/chat/completions \\
  -H "Authorization: Bearer $STARVERI_API_KEY" \\
  -H "Content-Type: application/json" \\
  -d '{
    "model": "gpt-5.6-luna",
    "messages": [{"role": "user", "content": "Hello from Starveri"}],
    "max_completion_tokens": 512
  }'

from openai import OpenAI

client = OpenAI(
    api_key="$STARVERI_API_KEY",
    base_url="https://api.starveri.net/v1",
)
result = client.chat.completions.create(
    model="gpt-5.6-luna",
    messages=[{"role": "user", "content": "Hello from Starveri"}],
    max_completion_tokens=512,
)
print(result.choices[0].message.content)

const response = await fetch("https://api.starveri.net/v1/chat/completions", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.STARVERI_API_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    model: "gpt-5.6-luna",
    messages: [{ role: "user", content: "Hello from Starveri" }],
    max_completion_tokens: 512
  })
});
const result = await response.json();

Authentication

Authenticate every request with an API key in the HTTP Authorization header.

Authorization: Bearer ocgptapi_…

Keys and billing are managed at api.starveri.net ↗. Use HTTPS and rotate a key immediately if it is exposed.

Models & pricing

Prices are per 1 million tokens unless stated otherwise. Values are the current Starveri reference rates.

Short vs Long context

For Standard requests, context pricing is selected from input-token usage. Long context doubles the selected Standard or Pro model-token price. Separately priced tools are unchanged. Flex does not use this context-pricing field.

Gemma 4 · Dedicated serving runtime

Gemma inference uses a dedicated serving runtime and Standard pricing. There is no Flex or Pro inference for either Gemma model. During capacity pressure, requests may wait in arrival order; if the serving runtime is unavailable, the API returns HTTP 503 instead of substituting another model.

Gemma models do not offer input-token caching, cache writes, or cached-input discounts. Both models expose a binary thinking control ("on" or "off", default "on"): they expose no reasoning modes and do not accept or send reasoning fields; the Playground presents the thinking toggle instead. The uncensored variant skips automatic omni and specialized policy moderation, but authentication, billing, account restrictions, rate limits, concurrency limits, and logging still apply.

Standard

Pro

Uses a Pro model or equivalent.

GPT Daybreak Blue

gpt-daybreak-blue is available through Standard service and is priced at 3× GPT-5.6 Sol Standard usage. It is disabled for every account by default; request enablement by emailing support@starveri.net. The same Standard long-context pricing rule shown above applies. Additional safety review and availability controls may apply.

Flex

Flex · Pro reasoning

Pro is a Flex reasoning effort, not Pro mode. Use "reasoning": { "effort": "pro" }. Flex rejects pro: true, agent_mode: true, Code Interpreter flags, and Code Interpreter tool declarations. Web Search is always enabled for Flex, even when web_search: false is supplied.

Only GPT-5.6 Sol and GPT-5.5 are available on Flex and Pro Flex. Flex reasoning efforts are Medium, High, Xhigh, and Pro for GPT-5.6 Sol; GPT-5.5 additionally supports None.

• Response times will be longer.
• Resources may at times be unavailable.
• Personality may be unpredictable.
• Context is not preserved and conversations cannot be continued.

Account tiers

Credits count toward tier usage when they are directly billed to a model.

Rate limits

Limits are account-wide across all API keys owned by the account. They reset at midnight UTC. Admin controls may override a tier limit, including capping Tier 5 concurrency.

Complimentary tokens

Complimentary tokens do not stack. Daily pools reset at midnight UTC. If a request would take you over the daily allowance, the entire request is billed.

Tools, flags & model behavior

{ "agent_mode": true }

{ "auto_route": "gpt-5.4-mini" }

Chat Completions

OpenAI-compatible endpoint:

POST https://api.starveri.net/v1/chat/completions

Required fields are model and messages. Use max_completion_tokens; the API also accepts the compatible max_output_tokens/max_tokens aliases where supported.

The API reads every supplied message in order. System and developer messages are merged into the request instructions. User, assistant, and tool messages are converted into one ordered transcript labeled User:, Assistant:, and Tool:. The server does not automatically retrieve an earlier Chat Completions request, so clients continue a conversation by sending the desired prior messages again on every request.

{
  "model": "gpt-5.6-terra",
  "messages": [
    {"role": "system", "content": "You are concise."},
    {"role": "user", "content": "Summarize this."}
  ],
  "max_completion_tokens": 1024,
  "stream": false,
  "agent_mode": false,
  "pro": false,
  "web_search": false,
  "code_interpreter": false
}

Responses API

Use the OpenAI Responses shape at:

POST https://api.starveri.net/v1/responses

{
  "model": "gpt-5.6-luna",
  "input": "Explain the result in three bullets.",
  "max_output_tokens": 512,
  "stream": true
}

Responses requests use the compatible Chat Completions executor and return a typed Responses object or semantic SSE events. The supported core includes text, image/file input parts, function calls, function-call outputs, reasoning configuration, tools, and max_output_tokens.

Set store: true on a non-streaming Response to persist its completed object. Retrieve it with GET /v1/responses/{response_id} or delete it with DELETE /v1/responses/{response_id}; stored responses are isolated by account.

Current compatibility boundary: use stateless request history for multi-turn tool loops. previous_response_id, conversation, background, and stored streaming responses return a typed unsupported_parameter error until the persistent stream lifecycle is available.

from openai import OpenAI

client = OpenAI(
  api_key=os.environ["STARVERI_API_KEY"],
  base_url="https://api.starveri.net/v1",
)
response = client.responses.create(
  model="gpt-5.6-luna",
  input="Explain the result in three bullets.",
  max_output_tokens=512,
)
print(response.output_text)

Image Generation

Use the OpenAI-compatible image endpoint for moderated image generation:

POST https://api.starveri.net/v1/images/generations

{
  "model": "image-gen",
  "prompt": "A quiet mountain lake at sunrise",
  "n": 2,
  "referenced_image_ids": ["file_..."]
}

Images use the GPT-5.6 Luna backend. Current verified support is limited to model, a text prompt, n from 1 through 10, and protected reference image file IDs. Billing is 0.5 credits per successful output image plus prompt and reference image inputs billed at GPT-5.6 Luna input pricing; input cost varies with the request, so the total is not fixed. Output is moderated and validated before it is released; a response can include per-image errors alongside successful results.

Upload references with POST /v1/files and pass the returned protected file IDs. Size, transparent-background, and style-transfer controls are not currently supported and should not be sent.

Streaming

Set stream: true to receive Server-Sent Events. Chat Completions streams end with data: [DONE]; Responses streams end with a typed response.completed, response.incomplete, or error event. A client disconnect cancels upstream work and Starveri reconciles metered usage.

curl https://api.starveri.net/v1/chat/completions \\
  -H "Authorization: Bearer $STARVERI_API_KEY" \\
  -H "Content-Type: application/json" \\
  -d '{"model":"gpt-5.6-luna","messages":[{"role":"user","content":"Stream this."}],"stream":true}'

When output is capped, the final choice uses finish_reason: "length" and Responses includes incomplete details for max_output_tokens.

Usage & billing

Starveri reserves a maximum-output credit hold before work starts, then reconciles to actual model/tool usage. Unused reserved credits are released. Interruptions are billed only for usage already observed; an interruption before metered usage releases the hold. Account-wide limits apply across every key owned by the account, while admin overrides can raise or cap those limits.

Usage fields

usage: {
  prompt_tokens,
  completion_tokens,
  total_tokens,
  prompt_tokens_details: { cached_tokens },
  completion_tokens_details: {
    reasoning_tokens,
    tool_tokens,
    web_search_tokens
  }
}

Starveri billing receipt

starveri_billing: {
  exact: true,
  settled: true,
  currency: "CREDITS",
  billed_credit_nanos,
  billed_credits,
  balance_credit_nanos,
  pricing_profile,
  breakdown
}

Tool charges are added to token charges. Web Search is per call; Coding Interpreter is based on RAM and disk minutes. Billing activity may include an interrupted 499 record with the observed usage.

Automation & server examples

Keep automation on a trusted server. Store STARVERI_API_KEY in the runtime secret manager and call the API over HTTPS. Use a bounded output limit, retries with backoff for transient failures, and an idempotency key in your own job record.

// Node.js scheduled job
const result = await fetch("https://api.starveri.net/v1/chat/completions", {
  method: "POST",
  headers: { Authorization: `Bearer ${process.env.STARVERI_API_KEY}`, "Content-Type": "application/json" },
  body: JSON.stringify({
    model: "gpt-5.6-luna",
    messages: [{ role: "user", content: "Generate the daily report." }],
    max_completion_tokens: 800
  })
});
if (!result.ok) throw new Error(`Starveri failed: ${result.status}`);

For long-running streams, propagate cancellation from the client/job controller and persist the response x-request-id with your own job state. Every execution response includes x-request-id and a Server-Timing: starveri;dur=… edge-processing measurement; rate-limit responses retain Retry-After when applicable.

Errors

Errors use an OpenAI-compatible envelope. Handle the HTTP status and inspect the stable fields before retrying.

{
  "error": {
    "message": "Human-readable explanation",
    "type": "invalid_request_error",
    "param": "max_completion_tokens",
    "code": "invalid_value"
  }
}

• 401 — missing, invalid, revoked, or malformed credentials.
• 402 — insufficient prepaid credits.
• 403 — requested capability is disabled for the key/tier.
• 409 — context or request conflict.
• 413 — upload too large.
• 429 — rate limit; honor Retry-After when present.
• 5xx — upstream or service failure; retry only when the response is safe to replay.

Files & uploads

File endpoints are OpenAI-compatible and require a key with upload capability. Validate ownership before attaching a file to a request. Never log raw file contents or data URLs.

POST https://api.starveri.net/v1/files
Content-Type: multipart/form-data
Authorization: Bearer $STARVERI_API_KEY

Image-capable models can receive images. Spark is text-only and uses the documented gpt-5.4-mini transcription path. Image generation references use protected file IDs; upload size and purpose-specific limits are enforced by the API, so check the response error object for the exact rejection.