Error Codes & Limits.
Gateway error JSON format, status-to-type mapping, Retry-After behaviour, body, timeout and rate limits, and all gateway error codes.
Error format & handling.
The gateway answers every error — including upstream provider errors — with a unified JSON object under error carrying a stable code, a status-derived type and an English message (plus retry_after in seconds on mid-stream errors after HTTP 200). Always match on error.code in application code rather than message. On status codes 500 and above, message ends with (request id <id>), matching the x-request-id and request-id headers.
{
"error": {
"type": "insufficient_quota",
"code": "key_budget_exhausted",
"message": "This API key has reached its spending limit.",
"param": null
}
}{
"type": "error",
"error": {
"type": "billing_error",
"code": "key_budget_exhausted",
"message": "This API key has reached its spending limit."
},
"request_id": "4f1c9a20"
}HTTP/1.1 429 Too Many Requests
content-type: application/json
retry-after: 5
x-noirdoc-provider: ionos
x-request-id: 4f1c9a20
{
"error": {
"type": "rate_limit_error",
"code": "resource_exhausted",
"message": "The requested resource is temporarily at capacity.",
"param": null
}
}OpenAI endpoints always include “param”: null; /v1/messages and
/v1/skills use the Anthropic envelope with request_id. Only on
/v1/files does x-api-key select the Anthropic envelope while
Authorization: Bearer and api-key select the OpenAI envelope.
Status-to-type mapping
| Status | type on OpenAI endpoints | type on /v1/messages and /v1/skills |
|---|---|---|
| 400, 405, 409, 422 | invalid_request_error | invalid_request_error |
| 401 | authentication_error | authentication_error |
| 402 | insufficient_quota | billing_error |
| 403 | permission_error | permission_error |
| 404 | not_found_error | not_found_error |
| 413 | invalid_request_error | request_too_large |
| 429 | rate_limit_error | rate_limit_error |
| 500, 502 | server_error | api_error |
| 503 | server_error | overloaded_error |
| 504 | server_error | timeout_error |
| 529 | not used | overloaded_error |
Provider errors & BYOK
When a provider returns an error, the gateway normalises it into the error envelope above. On capacity or overload errors it first tries up to three providers for the model (failover), temporarily skipping a managed provider that returned 429 for the duration in its Retry-After header (1–60 s, 10 s without header, 60 s when quota is exhausted):
| Upstream response | Managed provider | Own provider key (BYOK) |
|---|---|---|
| 429 or 402 (capacity / quota) | 429 resource_exhausted with Retry-After (after failover) | provider_rejected_request with upstream status & message (with Retry-After 1–60 s on 429, else 5 s) |
| 503 or 529 (overload) | provider_overloaded with Retry-After (status 503 on OpenAI routes, 529 on /v1/messages and /v1/skills) | provider_overloaded with Retry-After |
| 400, 404, 422 and other 4xx request errors | Immediate provider_rejected_request with upstream status and sanitised message (at most 500 characters; "The provider rejected the request." if non-JSON; 4xx message text is not logged) | Immediate provider_rejected_request with upstream status and message |
| 401, 403 or other 5xx | 502 provider_error (fixed message) | provider_rejected_request on 401/403; 502 provider_error on 5xx |
Responses expose only the headers set by the gateway (Content-Type, X-Noirdoc-Provider, X-Noirdoc-Shield, X-Noirdoc-Masked, X-Request-ID, Request-ID, Retry-After, plus Content-Disposition on audio and file downloads); upstream headers such as x-ratelimit-* are stripped.
Retry-After & mid-stream errors
| Status | Code | Retry-After (seconds) |
|---|---|---|
| 429 | starter_rate_limit_exceeded | Remaining seconds in the current minute (1–60 s) or current UTC day |
| 429 | resource_exhausted | Provider value if between 1 and 60 s, otherwise 5 s |
| 503, 529 | provider_overloaded | Provider value if between 1 and 60 s, otherwise 5 s |
| 503 | capacity_exhausted | Estimated seconds until a provider frees up (at most 60 s), otherwise 5 s |
| 503 | shield_unavailable, service_overloaded, forwarding_pool_exhausted, ownership_check_unavailable, provider_auth_unavailable | 5 s |
| 503 | masking_unavailable (legacy masking until 2026-11-30) | 10 s |
| 504 | provider_timeout | 10 s |
If a stream fails after HTTP 200 has already been sent (for instance after : ping keep-alives, mid-stream disconnection with stream_interrupted, or gateway_restarting with "retry_after": 5), the gateway closes the stream with an error event in the endpoint’s wire format:
/v1/chat/completions:data: {"error": {"type": "...", "code": "stream_interrupted", "message": "...", "param": null}}followed bydata: [DONE](raisesAPIErrorin the OpenAI SDKs)./v1/responses: SSEerrorevent followed bydata: [DONE](checkevent.type == "error"in OpenAI Python SDK loops)./v1/messages: SSEerrorevent followed byevent: message_stop.
import os
import httpx
RETRYABLE = {
"starter_rate_limit_exceeded",
"resource_exhausted",
"provider_overloaded",
"capacity_exhausted",
"shield_unavailable",
"service_overloaded",
"forwarding_pool_exhausted",
"provider_timeout",
}
res = httpx.post(
"https://api.noirdoc.de/v1/chat/completions",
headers={"Authorization": f"Bearer {os.environ['NOIRDOC_API_KEY']}"},
json={
"model": "qwen3.8-27b",
"messages": [{"role": "user", "content": "Hello"}],
},
timeout=400,
)
if res.status_code >= 400:
err = res.json().get("error", {})
code = err.get("code", "unknown")
if code in RETRYABLE:
wait = int(res.headers.get("retry-after", 5))
print(f"Retry after {wait} s ({code}).")
else:
print(f"Error {code}: {err.get('message')}")const RETRYABLE = new Set([
"starter_rate_limit_exceeded",
"resource_exhausted",
"provider_overloaded",
"capacity_exhausted",
"shield_unavailable",
"service_overloaded",
"forwarding_pool_exhausted",
"provider_timeout",
]);
const res = await fetch("https://api.noirdoc.de/v1/chat/completions", {
method: "POST",
headers: {
Authorization: `Bearer ${process.env.NOIRDOC_API_KEY}`,
"Content-Type": "application/json",
},
body: JSON.stringify({
model: "qwen3.8-27b",
messages: [{ role: "user", content: "Hello" }],
}),
});
if (!res.ok) {
const body = await res.json().catch(() => null);
const code = body?.error?.code ?? "unknown";
if (RETRYABLE.has(code)) {
const wait = Number(res.headers.get("retry-after") ?? 5);
console.log(`Retry after ${wait} s (${code}).`);
} else {
console.log(`Error ${code}: ${body?.error?.message ?? res.status}`);
}
}Gateway limits.
This table consolidates all body-size, timeout, rate and parameter limits enforced by the gateway itself (1 MB = 1024 × 1024 bytes). Tighter model-specific limits at a provider (such as context window length) are returned as provider_rejected_request.
| Area / endpoint | Limit | Error when exceeded |
|---|---|---|
Body /v1/files & /v1/skills (incl. sub-paths) | at most 600 MB | 413 request_too_large |
Body all other /v1/* endpoints | at most 160 MB | 413 request_too_large |
Body /v1/audio/transcriptions (multipart total) | at most 26 MB | 413 request_too_large |
| Connecting to a provider | 10 s per provider | 504 provider_timeout |
| Waiting for provider data (non-stream / stream) | 120 s per provider / 600 s total (: ping every 15 s) | 504 provider_timeout |
| Failover attempts per request | at most 3 providers of the same kind (never mixing BYOK and managed; 3xx returned unchanged) | Error of final attempt |
| Waiting for a free provider / upstream pool | up to 10 s / pool cap | 503 capacity_exhausted / 503 forwarding_pool_exhausted |
| Starter credit: model access (before first top-up) | starter-eligible models only on managed providers | 403 starter_model_not_allowed |
| Starter credit: rate limits (before first top-up) | 5 requests/minute and 25 requests/day (UTC) per organisation on managed providers (requests rejected by the minute limit or starter_model_not_allowed do not count towards the daily limit) | 429 starter_rate_limit_exceeded with Retry-After |
| Rate limits after first confirmed top-up / invoice / BYOK | no per-customer or per-key rate limits set by the gateway (credit & budgets cap spend via status 402) | — |
| Noirdoc Shield: inspected text per gateway request | at most 4 MiB of encoded text | 413 shield_input_too_large |
| Inline UTF-8 text attachments under Shield | under 4 MiB decoded (4 MiB+ as well as binary files, images, audio and file_id: without enforced sets X-Noirdoc-Shield: partial; redacted=<n>; legacy file analysis until 2026-11-30: default 25 MB per file or 422 file_unprocessable) | 422 shield_uninspectable_content (enforced), 403 file_content_not_allowed (toggle off) |
POST /v1/shield/inspect: input | 1 to 64 non-empty strings, at most 256 KB UTF-8 combined | 400 invalid_request_error |
Shield custom_patterns | at most 100 patterns, 2 to 256 characters each (re: regex or case-insensitive literal) | 400 invalid_request_error |
POST /v1/rerank | non-empty query string, 1 to 1,000 documents strings, optional top_n >= 1 (text only) | 400 invalid_rerank_request |
POST /v1/audio/speech | input 1 to 4,096 characters, non-empty voice string | 400 invalid_tts_request |
POST /v1/images/generations | non-empty prompt, n 1 to 10 (default 1), size WIDTHxHEIGHT 1 to 2048 px per side (default 1024x1024, "auto" rejected), total at most 16 MP rounded up in 1024 × 1024 units | 400 invalid_image_request |
Request tags (X-Noirdoc-Tags & /v1/tags, Preview) | 1 to 5 comma-separated tags per request, 1 to 64 characters each (^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,63}$, not _default), at most 1,000 tags per organisation | 400 invalid_request_tags, 403 tag_limit_exceeded |
All error codes.
Reference of all gateway error codes grouped by HTTP status, with a direct anchor on every row such as #key_budget_exhausted:
| Code | Meaning | Fix |
|---|---|---|
| 400 Bad request | ||
invalid_request_path | The path contains a dot segment (. or ..), a %, a backslash or a control character. | Send the path without dot segments and without encoded characters, for example /v1/chat/completions. |
model_required | The request names no model (model in the body, or in the form field for /v1/audio/transcriptions). | Pass a model ID from GET /v1/models. |
wrong_endpoint_for_model | The model belongs to a different endpoint family or API format than the endpoint called. | Call the model through the matching endpoint, for example an embedding model through /v1/embeddings. |
streaming_not_supported_for_endpoint | The request asks for streaming, but the endpoint does not support it. | Remove stream from the request. |
invalid_request_body | The body is not a JSON object or not encoded in UTF-8. | Send the body as a JSON object in UTF-8 with Content-Type: application/json and check the field named in message. |
invalid_request_error | A parameter on /v1/shield/inspect or /v1/shield/policy is invalid (such as an empty input or one over 256 KB, more than 64 entries, an unknown rule or an invalid custom pattern), or the JSON body is nested too deeply for Shield extraction. | Check message and adjust input (1 to 64 non-empty strings, at most 256 KB in total), rules, mode or custom_patterns according to the /v1/shield reference. |
provider_rejected_request | The provider itself rejected the request, for example because of an invalid parameter or a context that is too long. The response carries the provider's status code (400, 404, 409, 413, 422 or another 4xx status code except 401, 402, 403 and 429), and message contains the provider's message, shortened and sanitised, at most 500 characters. On routes with your own provider key (BYOK) the gateway also reports the provider's status codes 401, 402, 403 and 429 this way, because the key, credit and quota belong to the customer; with 429 it adds Retry-After. | Correct the request based on the message. Repeating it unchanged fails again. X-Noirdoc-Provider names the provider. |
invalid_image_request | prompt, n or size is outside the gateway's limits; message names the parameter. | Correct the named parameter. Split large image requests into several requests. |
invalid_rerank_request | query is not a non-empty string, documents is not a list of 1 to 1,000 strings or top_n is not an integer of at least 1; message names the field. | Send query and each document as plain text, at most 1,000 documents per request, and top_n as an integer of at least 1. |
invalid_tts_request | input or voice is missing or empty, or input is too long. | Send input and voice as non-empty strings and shorten input to at most 4,096 characters. |
invalid_multipart_body | The body is not valid multipart/form-data, or model, stream or response_format appears more than once. | Send the audio file as a multipart form with each of these fields at most once. |
invalid_request_tags | The X-Noirdoc-Tags header or the tag name in the path under /v1/tags is empty, contains more than 5 tags or does not match the format ^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,63}$. | Send 1 to 5 comma-separated tag names of 1 to 64 characters each (a-z, A-Z, 0-9 and _ . : -, starting with a letter or digit). |
| 401 Not authenticated | ||
invalid_api_key | The key is missing, invalid or deactivated, or the organisation is not active. | Send a valid key starting with px- in the Authorization: Bearer, x-api-key or api-key (Azure style) header. Check the key under Models → API keys. |
| 402 Credit or budget | ||
insufficient_credit | The organisation's credit is used up or lower than the estimated maximum cost of the request (including Noirdoc Shield, also on BYOK routes when Shield is active). | Top up credit under Billing → Top up, or lower max_tokens or shorten the input. |
key_budget_exhausted | This key's budget is used up for the current period or does not cover the estimated cost of the request. | Raise the spending limit under Models → API keys, lower max_tokens or wait for the next reset. |
tag_budget_exhausted | The budget of a tag named in X-Noirdoc-Tags is used up for the current period or does not cover the estimated cost of the request; message names the tag. | Raise the tag's spending limit under Models → Tags or through /v1/tags, lower max_tokens or wait for the next reset. |
| 403 Not allowed | ||
endpoint_not_available_on_platform | The call would read data from the shared account of a provider managed by Noirdoc and is blocked there. | Connect your own provider key (BYOK) for this endpoint under Models → Providers. |
stored_responses_disabled | The request would store input and response at the managed provider (store, previous_response_id or a sub-route for stored responses), and your organisation has not turned on storage at the provider. | Send the history with every request, ask an admin to turn on “Allow Responses API storage at provider” under Models → Shield, or use your own provider key (BYOK). |
reference_not_available_on_platform | The body refers to objects at the provider (such as conversation, prompt.id or vector_store_ids) whose ownership the gateway cannot check for managed providers. | Remove the fields named in message or use your own provider key (BYOK). |
model_not_allowed_for_key | The model is not one of this key's allowed models. | Choose a model from GET /v1/models or extend the allowed models under Models → API keys. |
provider_not_allowed_for_tenant | The organisation counts as bound by professional secrecy (§ 203 StGB); this excludes every provider that offers this model. | Choose a model from GET /v1/models. The list contains only models with permitted providers. |
provider_not_allowed_for_key | The key's restrictions (providers, data residency, CLOUD Act, § 203) exclude every provider of this model. | Choose a model from GET /v1/models or relax the restrictions under Models → API keys. |
starter_model_not_allowed | The organisation is still using only its starter credit, and the model or its managed provider is not included in starter credit. | Choose a starter-eligible model from GET /v1/models, connect your own provider key under Models → BYOK, or top up credit once under Billing → Top up to unlock all managed models immediately. |
shield_violation | Noirdoc Shield blocked the request before forwarding to the provider because an active protection filter configured with block matched; message names the triggered rule (secrets, pii, ner, injection or custom). | Remove the triggering content from the request, or change the rule under Models → Shield or via /v1/shield/policy to redact or off (off only for injection). |
shield_policy_enforced | The organisation's Shield policy is enforced, and the request to /v1/shield/inspect tries to weaken an active rule or omit custom patterns via policy. | Omit policy or pass only equally strict or stricter rules (redact to block, or additional custom_patterns). |
masking_not_supported_for_endpoint | The endpoint supports neither Noirdoc Shield nor legacy masking, yet the policy is enforced or the request sends X-Noirdoc-Mask: on (and on /v1/images/generations also X-Noirdoc-Shield: on). During the legacy masking transition until 30.11.2026, this also affects /v1/embeddings and /v1/rerank on pre-existing organisations that have not switched to Shield yet. | Leave out the header. With enforced, an admin can change the default setting under Models → Shield; for /v1/embeddings and /v1/rerank, switching to Noirdoc Shield enables inspection. |
file_content_not_allowed | The request contains files, images or audio, and the organisation does not allow file content. | Send the request without files, or ask an admin to turn on “Allow file and image attachments in requests” under Models → Shield in Advanced Settings. |
file_pii_blocked | A file contains personal data, and the organisation's legacy file analysis (transition until 30.11.2026) is set to block or to detect_only under enforced. | Remove the personal data from the file, or switch to Noirdoc Shield under Models → Shield. |
model_not_billable | The model has no complete price on record, so it cannot be used with credit. | Choose another model or contact support. |
request_tags_disabled | The request sends X-Noirdoc-Tags or calls /v1/tags, but request tags (Preview) are not enabled for this organisation. | Remove the X-Noirdoc-Tags header or have request tags enabled for your organisation. |
tag_not_found | The named tag does not exist. On requests with X-Noirdoc-Tags, automatic tag creation is turned off (status code 403); on /v1/tags/{name}, the gateway answers with status code 404. | Create the tag under Models → Tags or with POST /v1/tags, or turn on automatic creation in the default tag template. |
tag_disabled | A tag named in X-Noirdoc-Tags is deactivated. | Activate the tag under Models → Tags or through /v1/tags, or remove it from X-Noirdoc-Tags. |
tag_limit_exceeded | The organisation has reached the maximum of 1,000 request tags. | Delete unused tags without spend history under Models → Tags or with DELETE /v1/tags/{name}, or reuse existing tags. |
insufficient_key_permissions | The API key lacks permission for /v1/tags (can_manage_tags) or /v1/shield/policy (can_manage_shield), a key pinned to shield_mode: on tries to weaken the Shield policy or a tag's shield_mode, or the tag requests broader models, providers or compliance rules than the calling key itself holds. | Turn on the corresponding management permission under Models → API keys (“Allow tag management (/v1/tags)” or “Manage Shield policy via API”) and modify policies only within that key's own constraints. |
model_not_allowed_for_tag | The model is not one of the allowed models of a tag named in X-Noirdoc-Tags. | Choose a model from GET /v1/models (with the same X-Noirdoc-Tags header) or extend the tag's allowed models under Models → Tags. |
provider_not_allowed_for_tag | The restrictions of a tag named in X-Noirdoc-Tags (providers, data residency, CLOUD Act, § 203) exclude every provider of this model. | Choose a model from GET /v1/models (with the same X-Noirdoc-Tags header) or relax the tag's restrictions under Models → Tags. |
| 404 Not found | ||
unsupported_endpoint | The gateway does not know this path. | Use an endpoint from the reference and check the spelling and the /v1/ prefix. |
object_not_found | The object (file, skill or stored response) does not exist or does not belong to your organisation. | Check the ID. Use only IDs that your organisation created through the gateway. |
model_not_available | The model ID is not available to the organisation. | Check the model ID with GET /v1/models. |
http_error | A request fails with a general HTTP error for which the gateway has no code of its own. The status code follows the error: 404 for an unknown path, 405 for a wrong method and 503 with Retry-After: 5 when an endpoint is not available in standalone mode. | Read message and check the method and path of the request. |
| 405 Method not allowed | ||
method_not_allowed | The endpoint accepts only POST. | Send the request with POST. |
| 409 Conflict | ||
tag_already_exists | A tag with this name already exists in the organisation. | Choose a different tag name or update the existing tag with PUT /v1/tags/{name} or PATCH /v1/tags/{name}. |
tag_has_spend_history | Spend has already been recorded for this tag, so it cannot be permanently deleted. | Leave the tag in the “Inactive” state so that counters and billing history remain intact. |
| 413 Request too large | ||
request_too_large | The body exceeds the endpoint's size limit. | Shrink or split the body, for example the audio file or embedded files. The values are listed under Limits. |
shield_input_too_large | The text to inspect in this request exceeds the Shield service limit of 4 MiB of encoded text in a single call. | Split large inputs or inline text files across several smaller requests. |
masking_input_too_large | A single text segment in a legacy-masked request (transition until 30.11.2026) exceeds the detector's character limit. | Split the text into smaller parts or switch to Noirdoc Shield under Models → Shield. |
| 422 Unprocessable | ||
shield_uninspectable_content | The Shield policy is enforced, and the request carries content that Shield cannot inspect as text (binary_document such as PDF or Office, media_not_inspectable such as images, audio or video, file_reference by ID or URL, file_too_large at 4 MiB or above, file_not_decodable or unrecognised_content). The gateway did not forward the request. | Extract the text beforehand and send it as message text or an inline UTF-8 text file under 4 MiB, or change the default setting from enforced to default_on under Models → Shield. |
shield_policy_invalid | The submitted Shield policy is inconsistent, such as enforced with all five protection filters set to off, or mixing rules/custom_patterns with flat rule keys. | Enable at least one protection filter when using enforced, and pass rule actions together inside the rules object. |
shield_config_invalid | The organisation's stored Shield configuration is invalid (for example enforced without any active protection filter, or a pattern that fails compilation); the gateway did not forward the request. | Review and re-save the protection filters and custom blocklist under Models → Shield or via /v1/shield/policy. |
file_unprocessable | A file could not be processed in legacy file analysis (transition until 30.11.2026): it is too large, unreadable or in a format without analysis. The gateway did not forward the request. | Save the file again or in another format (such as PDF, DOCX or XLSX), make it smaller, or extract the text beforehand for Noirdoc Shield. |
| 429 Rate limit or provider at capacity | ||
starter_rate_limit_exceeded | The organisation is still using only its starter credit and has reached the limit of 5 requests per minute or 25 requests per day (UTC) for managed providers. The response contains Retry-After with the wait in seconds. | Top up credit under Billing → Top up to lift the limit immediately, or wait the seconds from Retry-After. |
resource_exhausted | The provider reported capacity problems or exhausted credit (status code 429 or 402), even after failover across up to three providers. The response contains Retry-After with the wait in seconds. | Wait the seconds from Retry-After and send the request again. The OpenAI and Anthropic SDKs do this on their own. |
| 500 Internal error | ||
internal_error | An unexpected error occurred in the gateway. | Send the request again. If the error persists, give support the request ID from message or x-request-id. |
detection_error | Detecting personal data in legacy masking (transition until 30.11.2026) failed; the gateway did not forward the request. | Send the request again. If the error persists, contact support or switch to Noirdoc Shield under Models → Shield. |
file_analysis_error | Reserved for file analysis errors. The gateway does not currently send this code. | Send the request again. |
| 502 Provider error | ||
provider_not_configured | The organisation has no suitable provider set up for this request. | Connect a provider for this API format under Models → Providers. |
provider_misconfigured | The configuration of the selected provider is invalid, for example a base URL that is not allowed. | Check the provider's base URL and settings under Models → Providers. If a provider managed by Noirdoc is affected, contact support. |
provider_unreachable | The gateway could not connect to the provider, or the connection dropped. | Send the request again after a short wait. |
provider_error | The provider answered with an error (status code 5xx except 503 and 529, or 401 and 403 on routes with a provider managed by Noirdoc) that the request did not cause. The gateway replaces the provider's message with a fixed text. On routes with your own provider key it reports 401 and 403 as provider_rejected_request. | Send the request again. If the error persists, give support the request ID from message or x-request-id. |
stream_interrupted | The provider's stream broke off or reported an error after the response had started. The error is in the stream itself, because status code 200 has already been sent by then. stream_interrupted carries no retry_after; only errors in the stream that correspond to an HTTP error with a wait carry it. | Discard the incomplete response and send the request again. |
| 503 Temporarily unavailable | ||
capacity_exhausted | All providers of the model were at their capacity limit or paused after a 429, even after a wait of up to 10 seconds. The response contains Retry-After with the seconds until a provider is expected to be free again, at most 60, or 5 seconds if that is not known. | Wait the seconds from Retry-After and send the request again. The OpenAI and Anthropic SDKs do this on their own. |
provider_overloaded | The provider reported overload (status code 503 or 529), even after failover across up to three providers. The status code is 503 on OpenAI endpoints and 529 on /v1/messages and /v1/skills. The response contains Retry-After with the provider's value between 1 and 60 seconds, otherwise 5 seconds. | Wait the seconds from Retry-After and send the request again. The OpenAI and Anthropic SDKs do this on their own. |
service_overloaded | The gateway is temporarily at capacity. The response contains Retry-After with 5 seconds. | Wait the seconds from Retry-After and send the request again. |
forwarding_pool_exhausted | All of the gateway's connections to the providers are in use. This is a limit of the gateway, not of a provider. The response contains Retry-After with 5 seconds. | Wait the seconds from Retry-After and send the request again. The OpenAI and Anthropic SDKs do this on their own. |
provider_auth_unavailable | The gateway's credentials for the provider are currently unavailable. The response contains Retry-After with 5 seconds. | Send the request again later. |
ownership_check_unavailable | The gateway could not check just now whether the object belongs to your organisation and rejected the request. The response contains Retry-After with 5 seconds. | Send the request again. |
shield_unavailable | The Noirdoc Shield inspection service is temporarily unreachable; the gateway never forwards a request that requires inspection uninspected (fail-closed). The response contains Retry-After with 5 seconds. | Wait the seconds from Retry-After and send the request again. The OpenAI and Anthropic SDKs do this on their own. |
masking_unavailable | The legacy masking detector (transition until 30.11.2026) is temporarily unreachable; the gateway did not forward the request. The response contains Retry-After with 10 seconds. | Wait the seconds from Retry-After and send the request again. |
gateway_restarting | The gateway was restarted (deployment) while the stream was still waiting for the provider's response. The error is in the running stream, because status code 200 has already been sent by then. The error object contains retry_after with 5 seconds. | Wait the seconds from retry_after and send the request again. |
| 504 Timeout | ||
provider_timeout | The provider did not answer within the gateway's timeout. The response contains Retry-After with 10 seconds. | Wait the seconds from Retry-After and send the request again. |