API docs

Everything you need to integrate SeibertGPT into your own tools and scripts. OpenAI- and Anthropic-compatible.

Which interface does your tool use?
Applies to the whole page: the example, parameters and error format adapt.

Quick start

POST /v1/chat/completions
Base URLhttps://api.seibert.ai/v1
Modeldeepseek-v41-flash-fast
API keysgpt_…
as bearer token
Example with curl (OpenAI)
curl https://api.seibert.ai/v1/chat/completions \
  -H "Authorization: Bearer $SEIBERTGPT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "deepseek-v41-flash-fast",
       "messages": [{"role": "user", "content": "Hallo!"}]}'

Works with all tools that allow a custom base URL. For Anthropic SDKs and Claude Code, use https://api.seibert.ai.

Which tool fits your plan?

The more concurrent requests your plan allows, the more tools run smoothly. Choose your plan; clicking a tool takes you to its setup guide.

All setup guides
Recommended tools by plan. Choose a plan to highlight its column.
Tool
Weldall Client – to the setup guide
recommended
recommended
recommended
goose – to the setup guide
recommended
recommended
recommended
pi – to the setup guide
recommended
recommended
recommended
OpenWork – to the setup guide
works, but not recommended
recommended
recommended
opencode – to the setup guide
works, but not recommended
recommended
recommended
Claude Code – to the setup guide
works, but not recommended
works, but not recommended
recommendedincl. auto mode
  • Recommended
  • Works, but not recommended

All tools run with every plan. “Not recommended” means the tool needs more concurrent requests or a larger context window than the plan offers.

Models & parameters

One model, several variants. All variants belong to your plan and share its limits; /v1/models lists them too.

Model variants

GET /v1/models
  • deepseek-v41-flashStandard with thinking
  • deepseek-v41-flash-fastDefaultNo thinking – fast
  • deepseek-v41-flash-lowLow reasoning effort
  • deepseek-v41-flash-highHigh reasoning effort
  • deepseek-v41-flash-maxMaximum reasoning effort

Supported parameters

POST /v1/chat/completions
  • model
  • messages
  • stream
  • stream_options
  • max_tokens
  • max_completion_tokens
  • temperature
  • top_p
  • top_k
  • min_p
  • repetition_penalty
  • frequency_penalty
  • presence_penalty
  • stop
  • seed
  • response_format
  • tools
  • tool_choice
  • parallel_tool_calls
  • logprobs
  • top_logprobs
  • logit_bias
  • user
  • n
  • reasoning_effort

These fields are documented and supported; other fields in the request body come without any commitment. The list changes with the interface selected above.

Limits & fair use

Everyone shares the same GPUs. To keep individual large requests from slowing down everyone else, rules apply to new context: text the model doesn't have in its cache yet and has to read in full.

429burst_protection

Burst protection: a budget for new context

Your account has a budget of 400,000 tokens for new, uncached context. You can spend it all at once, for example on a large project. After that, it refills at 400,000 tokens per minute.

In an ongoing session, your tool sends the whole history every time, but whatever comes back unchanged is in the cache and doesn't count. Only what's new counts.

When it happens: The Retry-After header gives the number of seconds until there's enough budget again. Wait that long and send the request again.

Example, step by stepSchematic, without refilling between steps
Budget fullFull budget

Your account starts with a budget of 400k tokens for new context.

413cold_request_too_large

Large cold requests: not everything at once

“Cold” means the model doesn't have the context in its cache and has to read it in full again. With very large contexts, this noticeably slows down the GPU for everyone. That's why we reject:

  1. 1A new session with more than 350,000 tokens in the first request.
  2. 2A pause of more than 4 hours followed by more than 350,000 tokens. After such a long time, the cache is cold.
  3. 3More than 350,000 new tokens at once in an ongoing session.

If a session grows gradually, however, it may exceed 350,000 tokens in total.

In the Anthropic format we respond with 400 instead of 413: Claude Code ignores our message on a 413 and shows its own text instead, which is misleading here.

When it happens: Start a new session or shorten the context.

Three scenarios comparedSchematic
  1. 09:00
    New session200 OK
    Context 40kCache: new
    Started small, under 350,000.
  2. 09:20
    Kept working200 OK
    Context 210kCache: warm
    The previous history is in the cache.
  3. 09:40
    Continuing the history200 OK
    Context 490kCache: warm
    Going over 350,000 is fine here: only 280,000 are new.

Queue for concurrent requests

429

If all concurrent slots are occupied, a request waits up to 180 seconds, depending on your plan; no more requests can wait than your plan allows concurrently. After that, you get 429 (queue_timeout) with Retry-After.

During this time there's no response, not even comment lines in the stream. The queue applies to API keys, not to the chat in the portal.

queue_timeout

IP binding

403

IP binding depends on your active plan.

Each customer can book one subscription and one pass at the same time. Your plan states how many keys you can use.

ip_locked

AI labeling

Header

API responses come from an AI system. The API labels every model response in machine-readable form with the HTTP header X-AI-Generated: true. If you reuse outputs, observe your own labeling obligations (Art. 50 AI Act).

X-AI-Generated: true

Error codes

The message explains the specific case in English. Have your code react to code, not to the text.

OpenAI error format
{
  "error": {
    "message": "Your plan allows 2 concurrent requests. Wait until one has finished.",
    "type": "rate_limit_error",
    "code": "concurrency_limit"
  }
}

Via /v1/messages, plan and quota errors use 402 instead of 429, and cold_request_too_large uses 400 instead of 413. The text in message is in English and may change; check code in your code instead.

400Request
  • invalid_requestThe request body is invalid.
  • context_length_exceededThe context is too long for your plan or the model – shorten the history.
401Key
  • invalid_api_keyKey is missing, wrong or revoked.
402Plan
  • no_active_planNo plan is active right now – for example outside the time window of a night pass.
403Access
  • ip_lockedThe key is currently bound to a different IP address (see IP binding).
  • key_limit_exceededYour plan allows fewer keys than you've created – this key can't be used right now.
  • ip_unknownThe client's IP address could not be determined.
404Model
  • model_not_foundThe model doesn't exist – /v1/models returns the available variants.
413Size
  • request_too_largeThe request body is too large. Check for status 413 here – not every one of these responses includes a code.
  • cold_request_too_largeFair use: request too large for a new or long-inactive session.
429Limits
  • quota_exceededThe token quota is used up (only for plans with a quota).
  • concurrency_limitToo many concurrent requests – wait until one has finished.
  • queue_timeoutThe maximum wait time in the queue ran out while all concurrent slots stayed occupied – try again after Retry-After.
  • burst_protectionFair use: too much new context in a short time – wait the number of seconds given in Retry-After.
  • too_many_requestsToo many requests in a short time, or too many attempts with an invalid key from your IP address – wait the seconds given in Retry-After.
503Availability
  • upstream_unavailableThe model can't be reached right now, or your plan can't be checked right now – try again later.

Ready for your first request?

Create an API key and enter the base URL and model in your tool.

Create API keyCompare plans