Ga naar de inhoud

API-referentie

Authenticatie, endpoints, streaming, reasoning en fouten op het OpenAI-oppervlak, de native Anthropic-API's en de compatibiliteitsmatrix per endpoint.

Authenticatie

Elk verzoek naar /v1/* authenticeert met een virtuele key in de Authorization: Bearer-header. Maak keys aan onder Workloads in de Console.

  • Het geheim wordt één keer getoond en alleen de hash wordt opgeslagen.
  • Een key is een inlogcredential voor een workload. De workload bepaalt ratelimieten, budget, toegestane modellen en beleidsuitzonderingen. Het organisatiebeleid blijft gelden.
  • Een key kan een optionele vervaldatum hebben. Daarna wordt de key geweigerd, precies als een onbekende key.
  • Een model dat niet op de niet-lege toegestane lijst van de workload staat, wordt geweigerd met een verzegelde 403 permission_error voordat er iets wordt verzonden. De weigering zelf komt in de auditketen.
  • Een workload kan zijn keys beperken tot endpointfamilies, bijvoorbeeld chat en embeddings. Andere families krijgen een verzegelde 403 operation_not_allowed voordat er iets wordt verzonden.
  • Voor een productiekey is een geverifieerd e-mailadres nodig.
  • Eén uitzondering: de ondertekende downloadlinks voor geanonimiseerde documenten, die beperkt geldig zijn, hebben geen key nodig.
Workload-inloggegevens: beheer API-keys en hun toegangsinstellingen.
Workload-inloggegevens: beheer API-keys en hun toegangsinstellingen.Engelstalige interface · illustratieve demogegevens. Open de afbeelding op volledig formaat.
curl https://api.sluis.ai/v1/models \
  -H "Authorization: Bearer $SLUIS_KEY"

# a model outside the workload's allow-list never dispatches:
# → 403 permission_error, and the refusal is sealed in the audit chain

Endpoints

Sluis biedt hieronder het OpenAI-compatibele oppervlak, plus de native Anthropic-paden die verderop staan beschreven.

Endpoints zonder eigen handler worden ongewijzigd doorgestuurd naar de gerouteerde provider, streaming inbegrepen, zodat OpenAI-compatibele upstreams hun volledige getrouwheid houden.

Een browser die een pad opent dat de API niet bedient, zoals de kale API-host, wordt doorgestuurd naar deze docs. API-clients krijgen gewoon een 404.

EndpointDoel
POST /v1/chat/completionsChat completions, het hoofdoppervlak: routing, gegevensbescherming, caching, streaming.
POST /v1/completionsVerouderde tekstcompletions.
POST /v1/embeddingsEmbeddings.
POST /v1/moderationsModeratieclassificatie.
POST /v1/responsesDe OpenAI Responses API.
POST /v1/systemoneNative System One typed decisions, not OpenAI chat messages.
POST /v1/ocrDocument-OCR (Mistral, of volledig lokaal met model sluis/ocr), gefactureerd per pagina. Met het beleid dlp_documents aan worden inline documenten geanonimiseerd voordat ze vertrekken.
POST /v1/documents/anonymizeDocumentanonimisering: persoonsgegevens vervangen door «MERGE_TAG»s, afbeeldingen vervaagd. Gefactureerd per pagina of afbeelding.
POST /v1/documents/anonymize/jobsAsynchrone anonimiseringsjobs: zet een groot document in de wachtrij, poll /jobs/{id} en haal /jobs/{id}/result op. De ondertekende downloadlink (/v1/documents/deliverables/{id}) is beperkt geldig en heeft geen API-key nodig.
GET /v1/modelsModellen toegestaan door je beleid, credentials en workload, met type, contextvenster, mogelijkheden, residency, aliasdoel en de uiteindelijke EUR-prijs van deze organisatie, exclusief btw.
GET /v1/models/{id}Metadata en organisatiespecifieke prijs van één model, in dezelfde vorm als de lijst.
POST /v1/audio/*Transcriptie, vertaling en spraak, doorgestuurd naar de gerouteerde provider. Met model sluis/transcribe voert POST /v1/audio/transcriptions de eigen spraakherkenning van Sluis uit, met sprekerherkenning. Zie Spraak naar tekst.
POST /v1/images/*Beeldgeneratie en bewerkingen, doorgestuurd. mistral/image-generation is de uitzondering: Mistral levert dit alleen via zijn agentconnector, dus de gateway vertaalt het OpenAI-verzoek en antwoordt met b64_json, gefactureerd per afbeelding.
POST /v1/video/generationsVideogeneratie, doorgestuurd.
/v1/filesBestandsbewerkingen, doorgestuurd op de eigen key van je organisatie (BYOK of een eigen provider). Bestanden met purpose=batch zijn de uitzondering: zij gaan via de eigen poort van de gateway en mogen beheerde keys gebruiken.
/v1/batchesBatches in OpenAI-vorm: upload een JSONL-bestand met purpose=batch naar /v1/files, en maak, poll en annuleer ze hier. Elke regel doorloopt gegevensbescherming en residency als een live call. Resultaten komen binnen 24 uur, gefactureerd voor de helft van de live prijs. Mistral, Azure, OpenAI en Qwen.
POST /v1/messages/batchesAnthropic Message Batches: aanmaken, lijst, ophalen, resultaten en annuleren. Uit tenzij je uitrol ze inschakelt. Ze vereisen contentbewaring en draaien alleen op Anthropic-modellen. Anders geven deze routes 404.
POST /v1/messagesNative Anthropic Messages-ingress: richt elke Anthropic-SDK-tool op Sluis, met elk verbonden model.
POST /v1/messages/count_tokensLokale tokenschatting voor contextbeheer van de Anthropic SDK. Er wordt niets verzonden.
GET /anthropic/v1/modelsNative Anthropic-modelontdekking (lijst en ophalen), beantwoord vanuit de catalogus in het proces. Op /v1/models kiest de anthropic-version-header dezelfde vorm.
HEAD /api/helloWarm-upprobe voor Anthropic-SDK-clients zoals Claude Code: 200 met een lege body.
GET /v1/realtimeOpenAI Realtime-compatibele WebSocket voor live spraak-naar-spraak met vertex/gemini-3.8-live, gehost in de EU-multiregio op Google Vertex AI. Ook beschikbaar op /openai/v1/realtime; de queryparameter model is verplicht. Authenticeer het upgrade-verzoek met Authorization: Bearer of x-api-key. Het spreekt de GA-eventnamen; de bètavormen OpenAI-Beta: realtime=v1, tijdelijke client secrets, browser-subprotocolsleutels en G.711-audio worden niet ondersteund. Server-side tools, sessiehervatting, stemreplicatie en avatar-uitvoer worden bij de setup geweigerd. Tekst wordt beschermd zoals op elk endpoint; audio- en videoframes worden ongeïnspecteerd doorgestuurd. Een sessie eindigt bij een bestedingsplafond van 2 EUR, en de provider sluit een verbinding na ongeveer 10 minuten; maak opnieuw verbinding om door te gaan. Gefactureerd per token tegen de tarieven per modaliteit van het model (tekst, audio, beeld- en videoframes), volgens het gebruiksrapport van de provider. Niet beschikbaar in Sluis Workspace, de Playground of sluis/*-aliassen. De volledige eventlijst staat in de agent skill.
GET /ws/google.ai.generativelanguage.v1beta.GenerativeService.BidiGenerateContentNative Gemini Live-WebSocket (BidiGenerateContent), ook op /ws/google.cloud.aiplatform.v1.LlmBidiService/BidiGenerateContent; de versie in de servicenaam mag v1, v1beta, v1beta1 of v1alpha zijn. Een google-genai-SDK met de gateway-origin als basis-URL verbindt ongewijzigd. Authenticeer het upgrade-verzoek met x-goog-api-key, Authorization: Bearer of x-api-key; de queryparameter ?key= wordt niet geaccepteerd. Frames worden doorgegeven zoals het Gemini Live-protocol ze definieert, en setup.model is gemini-3.8-live. Weigeringen komen binnen als WebSocket-close-frame met de reden als tekst. Hetzelfde model, dezelfde limieten, dezelfde gegevensbescherming en dezelfde facturatie als /v1/realtime.
curl https://api.sluis.ai/v1/chat/completions \
  -H "Authorization: Bearer $SLUIS_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "model": "mistral/mistral-large-latest",
        "messages": [{ "role": "user", "content": "Say hi" }] }'
Playground met een gekozen model en een afgerond voorbeeldverzoek.
Playground met een gekozen model en een afgerond voorbeeldverzoek.Engelstalige interface · illustratieve demogegevens. Open de afbeelding op volledig formaat.

Elke JSON-body hierboven mag daarnaast de gateway-extensie sluis.remove dragen, die termen noemt die vóór verzending uit de prompt gepseudonimiseerd moeten worden. Ze wordt verwijderd voordat het verzoek de gateway verlaat; zie de Gegevensbeschermingsreferentie.

# Document OCR, billed per page. Returns pages[] markdown + usage_info.pages_processed.
# model "sluis/ocr" runs the gateway's own OCR engine: fully local, no provider egress (inline data: URLs only).
curl https://api.sluis.ai/v1/ocr \
  -H "Authorization: Bearer $SLUIS_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "model": "mistral/mistral-ocr-latest", "document": { "type": "document_url", "document_url": "https://example.com/invoice.pdf" } }'

Spraak naar tekst met sprekerherkenning

Zet het model op sluis/transcribe en stuur POST /v1/audio/transcriptions. De gateway voert zijn eigen spraakherkenning uit, zonder uitstroom naar providers.

  • Stuur een multipart file van maximaal 240 minuten. De taal wordt automatisch herkend.
  • response_format is json (standaard), text of verbose_json (segmenten met een spreker).
  • Gefactureerd tegen €0,02 per minuut audio, per begonnen seconde.
  • De DLP-modus van de organisatie geldt voor de transcriptie, zoals bij sluis/ocr.
  • Het antwoordt 503 waar de uitrol geen transcriptie draait.
# Speech to text with speaker detection, billed €0.02 per minute of audio (per started second).
# model "sluis/transcribe" runs in the gateway's own worker: no provider egress, language detected automatically.
curl https://api.sluis.ai/v1/audio/transcriptions \
  -H "Authorization: Bearer $SLUIS_KEY" \
  -F model=sluis/transcribe \
  -F response_format=verbose_json \
  -F file=@meeting.m4a
# Document anonymization, billed per page/image. PII becomes «MERGE_TAG»s; images are blurred.
curl https://api.sluis.ai/v1/documents/anonymize \
  -H "Authorization: Bearer $SLUIS_KEY" \
  -F file=@contract.docx \
  -F 'options={ "entities": ["person_name", "email", "iban"], "remove": ["Project Nightingale"] }'
Playground Documents: upload een document om te anonimiseren.
Playground Documents: upload een document om te anonimiseren.Engelstalige interface · illustratieve demogegevens. Open de afbeelding op volledig formaat.

System One typed decisions

# The router behind sluis/auto: send state only, not questions.
curl https://api.sluis.ai/v1/systemone \
  -H "Authorization: Bearer $SLUIS_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"sluis/typed/router",
       "state":{"request":"Compare these two supplier contracts clause by clause and list the risks.",
                "previous":"Here are both contracts.",
                "attachments":["contract_a.pdf (application/pdf)","contract_b.pdf (application/pdf)"]}}'
Local router contract (sluis/typed/router)Behaviour
Model idssluis/typed/router is the router Sluis uses for sluis/auto, with its own calibrated questions. For your own questions, use a typesafe/jev-* model with your own TypeSafe key.
sluis/typed/routerSend the text a request carries: state.request (required), and optional previous, system and attachments (a string or a list of "name (mime)" strings); a plain string is the request. It answers reasoning (noul, P(needs multi-step reasoning)), complexity (score, 0 trivial to 3 hard, with legend and probabilities per level) and task (choice over code, writing, translation, extraction, document, support, smalltalk, action). decision holds the route and demand sluis/auto would take from this text alone, or null. Files, images, JSON mode, tools, prompt size and your organisation's policy are not part of this input and can change a real sluis/auto route. answers.reasoning keeps the keys it always had; the rest is additional.
TypeSafeBring your own key only; no sluis/* alias reaches it. Name the model explicitly, for example typesafe/jev-latest. The normal gate applies: it is a US provider, so your residency policy must allow US. The other rows describe sluis/typed/router only.
AvailabilityEvery answer comes from verified model weights, reported as revision. If the router is unavailable or cannot be verified, the call fails closed with 503.
StateRequired JSON object, list (array) or string, at most 128 KiB (131072 bytes) of serialized JSON before DLP. Missing or invalid state returns 422; oversized state returns 413.
Questionssluis/typed/router supplies its own calibrated questions: any questions field, including null or an empty object, returns 400.
ResponseJSON with model, answers, decision and revision (weights SHA256). Each answer has its type, its typed value (choice, score or noul), confidence, probabilities, legend and answer_confidence. No chat completion or streaming envelope.
Latencysluis/typed/router usually answers well under 200 ms; when busy it returns 503 with Retry-After: 2.
Data protectionTenant DLP applies locally to the state: block refuses; tokenize or mask rewrites what the router is shown. Per-request removal terms are honoured.
ResidencyProcessed on Sluis infrastructure with no outside provider and no upstream residency routing step.
MeteringEach successful local decision is sealed and billed per input token at €0.01 per 1M tokens; output is free. The router reports no token count, so input is estimated at about 4 characters per token over the state it was shown. Normal limits, budgets and model allow-lists still apply.
AliasesAn existing tenant alias with the same name takes precedence over the local router.

Documenten als invoer

Voeg een pdf-, Word-, afbeeldings- of tekstbestand toe aan een chatverzoek als contentonderdeel "type": "file" met een base64-file_data-data-URL.

Elk gerouteerd model accepteert het. Providers die bestandsonderdelen native begrijpen, ontvangen ze ongewijzigd. Voor elke andere provider zet de gateway het document om vóór het verzenden.

Hoe het model het document ontvangt

  • Met een pdf-renderer krijgen modellen met beeldondersteuning elke pdf-pagina als image_url-onderdeel. Het budget is 48 pagina's per verzoek, gedeeld over alle bijgevoegde documenten, en providerlimieten kunnen gelden. Zonder renderer haalt de fallback van de uitrol de tekst eruit of weigert het verzoek.
  • Modellen zonder beeldinvoer krijgen de uitleesbare tekst van het document als prompttekst. De scan van gegevensbescherming dekt die dan net als elke andere tekst.
  • Langere of zwaardere documenten horen op /v1/ocr.
  • De Responses API gebruikt input_file-onderdelen in plaats van de geneste file-vorm van chat completions.
  • Sluis kan file_id-verwijzingen aan providerzijde niet controleren of oplossen. Ze gaan alleen door naar een provider die ze ondersteunt, op je eigen providerkey, met documentcontrole uit. Zet anders de bytes inline als file_data.

Gegevensbescherming voor documenten

  • Met het beleid dlp_documents aan wordt het document geanonimiseerd of geweigerd voordat er iets de gateway verlaat.
  • Met het beleid uit en een beschermende DLP-modus (tokenize, mask of block) worden documenten geweigerd die als niet-controleerbare afbeeldingen zouden reizen. Onder allow_log gaan ze door met een expliciete markering 'niet gescand' in het auditspoor.
  • Audio-onderdelen (input_audio) kunnen niet worden gescand. block, of verplichte AI-herkenning met documentinspectie aan, weigert ze met 422. Anders dragen ze x-sluis-unscanned: audio.
# Attach a document as an OpenAI-style `file` content part. The gateway
# normalizes it for the routed provider, so this works on any model.
curl https://api.sluis.ai/v1/chat/completions \
  -H "Authorization: Bearer $SLUIS_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "model": "scaleway/gemma-4-26b-a4b-it",
        "messages": [{ "role": "user", "content": [
          { "type": "file",
            "file": { "filename": "drawing.pdf",
                      "file_data": "data:application/pdf;base64,'"$(base64 -w0 drawing.pdf)"'" } },
          { "type": "text", "text": "Which discipline does this drawing document?" }
        ] }] }'

Streaming

Zet stream: true en het antwoord komt als server-sent events. Elk frame is een chat.completion.chunk-delta, en de stream eindigt met data: [DONE].

Streams worden nooit in de gateway gebufferd: ze lopen er doorheen, en de auditverzegeling en de meting gebeuren ook als de client vroegtijdig ophangt.

Vraag stream_options.include_usage aan en de gateway vraagt de provider om een laatste usage-frame. Stuurt de provider er geen, of wordt de stream afgebroken, dan schat de gateway het verbruik voor de meting.

Wil je zien wat een gestreamde call je organisatie kostte? Stuur dan x-sluis-include-cost: true mee, samen met stream_options.include_usage. Het laatste usage-object bevat dan sluis_cost_eur, zie Kosten van een call.

Bedrock houdt redeneringen apart van het antwoord in reasoning_content en reasoning_signature, ook in gestreamde delta’s. Weigeringen gebruiken finish_reason: content_filter, uitvoerlimieten length, ook bij gedeeltelijke toolaanroepen. Voer geen onvolledige toolargumenten uit. AWS-streaminguitzonderingen worden foutframes zonder gevoelige details.

Keepalive, headers en herstarts

  • Na 15 seconden zonder frame schrijft de gateway een SSE-commentaarregel (: keepalive) tussen de events, zodat proxy's met idle-timeouts de verbinding openhouden terwijl een model nadenkt. SSE-clients negeren die regel.
  • Streams dragen Cache-Control: no-cache en X-Accel-Buffering: no.
  • Als een gateway-replica herstart, blijft hij open streams tot vijf minuten bedienen. Een stream die daarna nog openstaat, eindigt met een foutevent met code server_restarting, dus probeer het verzoek opnieuw.
  • Getokeniseerde streams accepteren losse events tot 4 MiB. Grotere events beëindigen de stream met een fout.
stream = client.chat.completions.create(
    model="mistral/mistral-large-latest",
    messages=[{"role": "user", "content": "Write a haiku"}],
    stream=True,
    stream_options={"include_usage": True},
)
for chunk in stream:
    print(chunk.choices[0].delta.content or "", end="")

Redeneren

Geef de OpenAI-parameter reasoning_effort (minimal | low | medium | high) mee op elk model dat kan nadenken. Sluis vertaalt hem per provider (het denkniveau van Gemini, de adaptieve denkinspanning van Claude) en laat hem weg waar een model hem zou weigeren, zodat één parameter werkt voor de hele catalogus.

resp = client.chat.completions.create(
    model="vertex/claude-opus-4-8",
    messages=[{"role": "user", "content": "Prove it step by step…"}],
    reasoning_effort="high",  # minimal | low | medium | high
)

Prompt-caching

Herhaalde promptvoorvoegsels (systeemprompts, tools, gespreksgeschiedenis) kunnen bij de provider worden gecachet om kosten en latentie te verlagen. Sluis vertaalt cache_control-blokken in Anthropic-stijl (optionele TTL van 5m of 1h) en de top-level prompt_cache_key en prompt_cache_retention van OpenAI per provider.

Meerdere grenzen van systeem- of assistant-breakpoints kunnen tijdens de vertaling samenvallen, ook bij gemengde TTL's.

ProviderGedrag prompt-cache
AnthropicExpliciete cache_control op systeemblokken, berichtinhoud en tools, inclusief TTL. Reads en writes worden apart gerapporteerd.
Bedrockcache_control wordt vertaald naar Converse cachePoint-blokken in system, messages en toolConfig.
OpenAI · AzureAutomatische caching. Na opt-in blijven prompt_cache_key en prompt_cache_retention behouden bij chat en Responses; niet-ondersteunde opties en markers worden verwijderd.
Gemini · VertexImpliciete Gemini-caching en het gemelde cachegebruik werken; expliciete cachedContent-verwijzingen worden niet ondersteund. Claude op Vertex vertaalt cache_control en TTL zoals Anthropic.
xAI · DeepSeek · Mistral · Qwen · Moonshot · ZhipuAutomatische caching waar beschikbaar; alle expliciete directives worden verwijderd. Moonshots native usage.cached_tokens wordt herkend.
ScalewayAutomatische caching waar beschikbaar; alle expliciete directives worden verwijderd. Reads gebruiken Scaleways officiële EUR-tarief voor gecachte input waar beschikbaar, niet LiteLLM.
NebulAutomatische caching waar beschikbaar; alle expliciete directives worden verwijderd. Reads gebruiken het officiële EUR-tarief voor gecachte input waar beschikbaar.
Nebius · nebius-euAutomatische caching waar beschikbaar; alle expliciete directives worden verwijderd. Officiële liveprijzen gebruiken geen LiteLLM-cachekorting; de LiteLLM-fallback kan een cachetarief leveren als een officiële modelprijs ontbreekt.
CustomNa opt-in door de organisatie gaan directives ongewijzigd door; ondersteuning is het contract van de operator.

Expliciete promptcaching is opt-in

Expliciete promptcaching is een instelling op organisatieniveau (provider_prompt_cache). Hij staat standaard uit en staat los van contentbewaring door Sluis en exacte antwoordcaching. Zet hem aan in Console › Data protection.

  • Gecachete voorvoegsels blijven bij de provider nadat gegevensbescherming van Sluis ze heeft gefilterd.
  • Als hij uit staat, verwijdert de gate prompt_cache_key, prompt_cache_retention, prompt_cache_options, cache_control en prompt_cache_breakpoint. Hij schakelt de eigen automatische caching van de provider niet uit.
  • Zonder eigen key voor een provider draaien calls op een Sluis-credential die andere organisaties delen. Bij OpenAI en Azure zet Sluis een van je organisatie afgeleide prompt_cache_key in plaats van de jouwe. Bij elke andere provider tonen de gecachete tokens in je verbruik 0. De facturering past nog steeds de echte cachekorting toe.

Facturering en limieten

  • Cache-reads en -writes zijn deelverzamelingen van het totaal aantal prompttokens, geen extra invoer. Reads gebruiken het beschikbare cachetarief.
  • Anthropic 1h-writes gebruiken het TTL-specifieke tarief als de verbruiksopsplitsing en het tarief beschikbaar zijn. Anders geldt het standaard aanmaaktarief.
  • Een ontbrekend cachetarief betekent gewone invoerprijzen, nooit nul facturering.
  • Cacheverbruik staat in de auditlade en in Usage & budget.
  • Lange prompts worden gefactureerd tegen het long-contexttarief van de provider. Zodra de prompt (gecachete tokens inbegrepen) de drempel van het model overschrijdt, wordt de hele call tegen dat tarief gefactureerd. Het staat onder de prijs in de Models-tabel.

Op een door Sluis beheerde key weigert Sluis een verzoek met 400, voordat er iets wordt verzonden, als het een toeslag kiest die Sluis niet kan meten:

  • een cache_control-ttl anders dan 5m, waar de provider die honoreert (Anthropic, Bedrock, Claude op Vertex)
  • een service_tier anders dan auto, default, flex of standard_only
  • de Anthropic long-context-bèta (context-1m) op een model waarvoor Sluis geen long-contexttarief heeft

Je eigen providerkey stuurt alle drie ongewijzigd door.

Foutcodes

Fouten gebruiken de OpenAI-foutenvelop; de waarde error.type weerspiegelt de HTTP-status, zodat de foutafhandeling van je SDK ongewijzigd blijft werken.

CodeWanneer
400 invalid_request_errorOngeldige requestbody of parameters.
400 invalid_request_errorModel-id zonder providerprefix. Elke aanroepbare id is provider/model, bijvoorbeeld mistral/mistral-large-latest. De melding luidt: model must be provider-prefixed.
400 invalid_request_errorHet verzoek bevat de verwijderde x-sluis-dlp-header. Overrides per verzoek zijn vervangen door optie-overrides per workload: stel ze in via Console › Workloads.
401 authentication_errorOntbrekende of onbekende API-key.
402 insufficient_quotaGeen actief plan, of het budget is bereikt. Activeer een plan of verhoog het budget. Het verzoek bereikt nooit een provider.
403 permission_errorDe key mist toestemming, bijvoorbeeld omdat het model niet op de toegestane lijst van de workload staat.
422 invalid_request_errorGeweigerd vóór het verzenden, bijvoorbeeld omdat gegevensbescherming in blokmodus het verzoek heeft herkend.
422 document_too_large_to_scanEen document is te groot voor het pad dat het nam: een pagina die op de minimale scanresolutie nog boven de pixellimiet van de render ligt, of een bestand boven de bytelimiet voor tekstextractie. Pagina's in groot formaat (tekeningen op A0 en A1) worden automatisch verkleind. Verklein of splits het document en verstuur opnieuw.
429 rate_limit_errorRatelimiet bereikt. Afgedwongen in de gateway, dus het verzoek raakt nooit een provider.
403 permission_errorGeblokkeerd door residency-beleid: geen toegestane jurisdictie bedient het verzoek. De body bevat de reden.
403 scope_violationGeweigerd door de scopebewaking van de workload in blokmodus: de call valt buiten de scope die voor die workload is geschreven. De melding bevat de reden van de bewaking en het verzoek bereikt nooit een provider.
422 malware_detectedHet geüploade bestand kwam overeen met een malwaresignatuur en is geweigerd voordat het werd opgeslagen of verwerkt. De naam van de signatuur wordt nooit teruggegeven.
503 pdf_renderer_unavailableEen inline pdf moest als paginabeelden worden verzonden omdat het gerouteerde model beeldinvoer leest, maar deze uitrol heeft geen pdf-renderer. Het wordt geweigerd in plaats van beantwoord vanuit uitgelezen tekst, want die zou weglaten wat een tekening of scan toont.
503 malware_scan_unavailableHet geüploade bestand kon niet op malware worden gescand (scanner uit of traag, of het bestand is groter dan de scanlimiet van 100 MiB), dus het is niet geaccepteerd. Er is niets opgeslagen. Probeer opnieuw met backoff.
503 scope_guard_unavailableDe scopebewaking van de workload staat in blokmodus maar kon geen oordeel vellen, dus de call wordt geweigerd in plaats van doorgelaten. Probeer opnieuw met backoff.
503 auth_unavailableDe gateway kon zijn keystore niet lezen en kon de key dus niet verifiëren. Het is niet bekend dat de key ongeldig is. Probeer opnieuw met backoff en respecteer Retry-After.
504 api_errorDe provider antwoordde niet binnen de antwoordtermijn van de workload: standaard 300 seconden, 10 tot 600 als de workload dat instelt, korter als het verzoek x-sluis-upstream-timeout meestuurde. error.sluis.cause is timeout. De gateway heeft de call niet opnieuw afgespeeld, omdat de provider hem mogelijk nog uitvoert. Verkort de prompt of vraag een langere termijn aan voordat je opnieuw verstuurt.
5xx api_errorUpstream-providerstoring na pogingen opnieuw. De circuit breaker stuurt verkeer om ongezonde providers heen. De body bevat de eigen melding van de provider en een error.sluis-object met de oorzaak en elke poging, met de upstreamstatus of transportfout en hoe lang het duurde.
{
  "error": {
    "message": "model must be provider-prefixed, e.g. \"mistral/mistral-large-latest\"",
    "type": "invalid_request_error",
    "param": null,
    "code": "invalid_request"
  }
}

Anthropic Messages API

Sluis spreekt de Anthropic Messages API native. Richt Claude Code of een Anthropic-SDK op de gateway en roep POST /v1/messages aan. /anthropic/v1/messages is het ondubbelzinnige pad met prefix naar dezelfde handler.

Het verzoek wordt vertaald naar de interne vorm, doorloopt dezelfde pijplijn Inspect, Route, Seal en Meter als elke andere call, en komt terug in het formaat van Anthropic, streaming inbegrepen.

Authenticatie

  • Stuur je Sluis-key mee in de x-api-key-header van Anthropic of in de gebruikelijke Authorization: Bearer-header. Beide worden geaccepteerd.
  • De anthropic-version-header wordt met elke waarde geaccepteerd en is nooit verplicht. Op GET /v1/models kiest zijn aanwezigheid de Anthropic-vorm.
  • Parsen is bewust open: onbekende bodyvelden, onbekende contentblocktypen, onbekende anthropic-beta-waarden en de ?beta=true-query die Claude Code stuurt worden getolereerd, niet geweigerd.
  • Beta-flags reizen byte voor byte naar upstreams uit de Anthropic-familie en worden elders genegeerd.

Endpoints

EndpointDoel
POST /v1/messagesMessages, gebufferd of streaming. Ondersteunt systeemprompts (string of blokken), tools en toolresultaten (inclusief foutresultaten en afbeeldingen daarin), afbeeldingen, documentblokken, thinking- en redacted_thinking-blokken in de geschiedenis, en cache_control-markeringen op elke cachebare positie.
POST /v1/messages/count_tokensLokale tokenschatting voor contextbeheer van de SDK. Er wordt niets verzonden, bewaard of gemeten.
GET /v1/models · GET /v1/models/{id}Native modelontdekking in de vorm van Anthropic, beantwoord vanuit de catalogus in het proces. Op het rootpad kiest de anthropic-version-header deze vorm, en zonder header krijg je de OpenAI-vorm. Onder /anthropic geldt hij altijd. De cursors before_id, after_id en limit zijn best effort, en created_at is een vaste placeholder omdat de catalogus geen releasedatum per model heeft.
HEAD /api/helloDe warm-upprobe die Claude Code vóór een sessie stuurt: alleen HEAD, beantwoord met 200 en een lege body.

Modelroutering

Het wireformaat beperkt het model nooit: de ingress is een codec, en de model-id bepaalt de route.

  • Een kale id zoals claude-sonnet-5 wordt opgelost via de standaardprovider van deze ingress, anthropic, tenzij je organisatie die elders naartoe wijst (bijvoorbeeld naar vertex voor Claude gehost in de EU). De residency-gate beslist nog steeds of dat doel het verzoek mag bedienen.
  • Leg een doel expliciet vast met een id met providerprefix, zoals vertex/claude-opus-4-8.
  • Of geef een sluis/*-alias mee. Een Anthropic-SDK-tool draait dan op elke verbonden provider, binnen je beleid.

Streaming

Met "stream": true is het antwoord de volledige eventgrammatica van Anthropic:

  • message_start, dan content_block_start, content_block_delta en content_block_stop voor elk blok, dan message_delta met cumulatief verbruik (inclusief cache-read- en aanmaaktokens), dan message_stop.
  • Tekst komt als text_delta, toolargumenten als input_json_delta, en redenering als thinking_delta plus signature_delta wanneer de gerouteerde provider die produceerde.
  • message_start bevat het aantal invoertokens als de provider dat in zijn eerste chunk meldt. Anders begint het op nul, en message_delta meldt het bijgewerkte verbruik.
  • Een ping-event volgt op message_start en herhaalt zich na ongeveer 15 seconden upstreamstilte, zodat een lange denkbeurt nooit de watchdog van een client activeert.
  • Een fout midden in de stream wordt opnieuw gecodeerd als een error-event in plaats van een afgebroken stream.
  • stop_sequence bevat de herkende reeks wanneer het antwoord van een provider uit de Anthropic-familie kwam, en is anders null.
  • Stuur x-sluis-include-cost: true mee en het verbruik in message_delta bevat ook sluis_cost_eur, de prijs van de call voor je organisatie in EUR, plus alleen bij een schatting sluis_cost_estimated: true. Zie Kosten van een call.
# native Anthropic Messages: the model id owns the route, not the wire format
curl https://api.sluis.ai/v1/messages \
  -H "x-api-key: $SLUIS_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{ "model": "vertex/claude-opus-4-8",
        "max_tokens": 256,
        "system": "Be concise.",
        "messages": [{ "role": "user", "content": "Say hi" }] }'

# /anthropic/v1/messages is the unambiguous prefixed path for the same handler

Fouten

Fouten van de Messages-handlers gebruiken de envelop van Anthropic: een top-level "type": "error" met het fouttype van de leverancier. Dat geldt ook voor weigeringen die nooit een model bereiken, zoals een onbekende key of een blokkade door gegevensbescherming.

De leverancierstypen zijn invalid_request_error, authentication_error, billing_error, permission_error, not_found_error, conflict_error, request_too_large, rate_limit_error, api_error en overloaded_error.

  • Het antwoord bevat een request-id-header en een request_id-bodyveld, de correlatie-id voor je client.
  • Waar de call een auditrij opleverde, identificeert de header x-sluis-request-id die rij. Een authenticatiefout heeft geen auditrij.
  • HTTP 5xx-antwoorden die de gateway afhandelt bevatten ook een aparte diagnostische x-request-id. Een veilige id van de client wordt ook bij andere antwoorden teruggestuurd. Fouten van een proxy vóór de gateway vallen buiten deze garantie.
  • Weigeringen op gatewayniveau die vóór de handler plaatsvinden, zoals ledger-backpressure of overbelasting, kunnen terugkomen in de OpenAI-foutvorm.
# failures from the Messages handlers are Anthropic-shaped: auth and
# data-protection refusals included
{
  "type": "error",
  "error": {
    "type": "rate_limit_error",
    "message": "rate limit exceeded"
  },
  "request_id": "req_9f2e…"
}

Een niet-lege mcp_servers-array wordt geweigerd met 400 invalid_request_error in plaats van doorgestuurd. Een model dat zelf een externe MCP-server aanroept, zou buiten de Sluis-gate vallen. Registreer de server in de Console en roep zijn tools aan via de MCP-gateway, waar elke uitgevoerde toolcall wordt gecontroleerd, gerouteerd, verzegeld en gemeten.

Compatibiliteitsmatrix

Wat de native ingangen vandaag dekken, endpoint voor endpoint. Deze tabel ís de claim: wat hier niet als ondersteund staat, is roadmap, wordt bewust geweigerd of is een ander productoppervlak, nooit stilzwijgend gesuggereerd.

AnthropicStatusToelichting
POST /v1/messages✓ nativeGebufferd en streaming, tools, afbeeldingen, documentblokken, thinking-round-trip en promptcache-markeringen.
POST /v1/messages/count_tokens✓ lokale schattingLokaal beantwoord. Er wordt niets verzonden.
GET /v1/models · /v1/models/{id}✓ nativeNative lijst- en ophaalvorm uit de catalogus in het proces. Via header onderhandeld op het rootpad, onvoorwaardelijk onder /anthropic.
HEAD /api/hello✓De warm-upprobe van Claude Code, alleen HEAD.
Message Batches✓ opt-inBeschikbaar als je uitrol het inschakelt: aanmaken, lijst, ophalen, resultaten en annuleren, voor modellen die naar Anthropic oplossen. Anders 404. Gebruik voor andere providers de /v1/batches in OpenAI-vorm.
Files✗ roadmapDe Files API wordt niet overgebrugd. Inline documentblokken en file_data dekken het gangbare pad.
mcp_servers✗ geweigerdEen niet-lege array wordt geweigerd met 400 in plaats van doorgestuurd. Registreer de server en gebruik de Sluis MCP-gateway.
Skills · Agents · Admin✗ buiten scopeSkills, managed agents en de admin-, verbruiks- en kosten-API's zijn een ander productoppervlak, geen inferentiecompatibiliteit.

Routing tussen protocollen

Leverancierspecifieke velden blijven behouden zolang het verzoek terechtkomt bij een provider die hetzelfde protocol spreekt. Een Anthropic-verzoek dat door een provider uit de Anthropic-familie wordt bediend, behoudt zijn thinking-blokken, cachemarkeringen, beta-flags en herkende stop_sequence.

Bij routing tussen protocollen worden die velden bij het verzenden weggelaten en nooit bij de ingress geweigerd. De auditrij legt zowel het wireformaat als de opgeloste provider vast, zodat elke achteruitgang is toe te schrijven.

Ondoorzichtige waarden worden nooit herschreven: thinking-signatures en redacted_thinking-payloads worden letterlijk doorgestuurd of helemaal niet. Daarom wordt een geparkeerd thinking-blok dat de scan van gegevensbescherming markeert, weggelaten in plaats van gemaskeerd: een herschreven blok zou een ongeldige signature dragen.