OpenAI API voor ontwikkelaars: gebruik een compatibele endpoint

De korte versie

De meeste handleidingen voor de openai-api voor ontwikkelaars gaan uit van één leverancier en één factuur. Het transportformaat is echter gewoon JSON over HTTPS, en veel clientcode, frameworks en tools kunnen met elke server communiceren die dit implementeert. Deze site hostt zo'n server. Je houdt je SDK, wijzigt de basis-URL, vervangt de sleutel door een sleutel van deze site en stelt het model in op uncensored.

Dat is de hele migratie voor een typische app. Hier is de checklist, en de rest van de pagina vult elke stap in.

1. Maak een account aan en claim het proeftegoed op de API-sleutelpagina.
2. Stel de base URL in op https://api.openaigatewayapi.com/v1.
3. Verstuur de API-sleutel als Authorization: Bearer <key>. De SDK's doen dit voor je wanneer je api_key doorgeeft.
4. Gebruik uncensored als model-ID in elk verzoek.
5. Verwerk HTTP 429 met een korte retry, zoals aan het einde wordt getoond.

Er zijn twee endpoints: POST /v1/chat/completions en GET /v1/models. De service is alleen voor tekst. Er is geen afbeeldings- of audiogeneratie, geen embeddings en geen fine-tuning, dus als je app daarvoor vraagt, heb je een andere provider nodig.

Controleer de verbinding met curl

Controleer voordat je aan je applicatie raakt of de sleutel werkt. Het models-endpoint is de goedkoopste test, omdat het geen tokens genereert.

Copyexport API_KEY="paste-your-key-here"

curl https://api.openaigatewayapi.com/v1/models \
  -H "Authorization: Bearer $API_KEY" | grep -o uncensored

De grep print het model-ID uncensored als de lijst dit bevat; verwijder de grep om de volledige JSON-lijst te zien. Als je een 401 krijgt, is de sleutel onjuist of mist de Bearer-prefix. Stuur nu een echt verzoek:

Copycurl https://api.openaigatewayapi.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [
      {"role": "system", "content": "You are a concise technical assistant."},
      {"role": "user", "content": "Explain idempotency keys in two sentences."}
    ],
    "temperature": 0.4
  }'

Het antwoord bevat de gebruikelijke choices- en usage-objecten. Het bevat ook koppen die het loggen waard zijn: X-Request-Id voor ondersteuningsvragen, X-Balance-USD voor je resterende tegoed, en de twee X-RateLimit-Limit-*-koppen die je limieten voor verzoeken en gelijktijdige verzoeken tonen.

Python met het officiële openai-pakket

In Python raak je alleen de clientconstructor aan. Alles daarna is de code die je al hebt.

Copyfrom openai import OpenAI

client = OpenAI(
    base_url="https://api.openaigatewayapi.com/v1",
    api_key="paste-your-key-here",
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You write short, accurate release notes."},
        {"role": "user", "content": "Summarise: added retry logic, fixed timeout bug."},
    ],
    temperature=0.5,
    max_tokens=200,
)

print(resp.choices[0].message.content)
print(resp.usage.prompt_tokens, resp.usage.completion_tokens)

Lees de sleutel uit een omgevingsvariabele in echte code. De sample hardcodeert deze alleen om de snippet kort te houden. max_tokens is hier optioneel; als je het weglaat, kan de completion alles gebruiken wat overblijft van het 100.000-token-venster gebruiken (prompt plus completion samen). Het toch instellen is een goedkope manier om de kosten bij een op hol geslagen generatie te beperken.

Streaming

Streaming gebruikt Server-Sent Events en dezelfde stream=True-vlag die je kent. Gebruikscijfers komen aan het einde van de stream, dus het laatste stukje kan een lege choices-lijst hebben.

Copyfrom openai import OpenAI

client = OpenAI(base_url="https://api.openaigatewayapi.com/v1", api_key="paste-your-key-here")

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "List five edge cases for a date parser."}],
    stream=True,
)

for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
    if getattr(chunk, "usage", None):
        print("\ntokens:", chunk.usage.total_tokens)

Eén detail is belangrijk voor capaciteitsplanning. Een gestreamd verzoek houdt zijn concurrency-slot vast tot de stream klaar is, niet tot het eerste token. Als een client een stream verlaat zonder deze te sluiten, blijft dat slot langer bezet dan je verwacht.

Node.js-voorbeeld

De Node SDK neemt dezelfde twee instellingen onder verschillende namen over.

Copyimport OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.openaigatewayapi.com/v1",
  apiKey: process.env.GATEWAY_KEY,
});

const completion = await client.chat.completions.create({
  model: "uncensored",
  messages: [
    { role: "user", content: "Write a regex that matches ISO 8601 dates, and explain it." },
  ],
  temperature: 0.3,
});

console.log(completion.choices[0].message.content);

Als je een framework gebruikt met een eigen OpenAI-integratie, zoek dan naar een veld met de naam basis-URL, API-basis of endpoint in de instellingen. Het plakken van dezelfde URL daar is meestal alles wat nodig is. Chat-frontend, agent-frameworks en editor-plugins volgen meestal dit patroon. Sampling-parameters zoals temperature, top_p, stop, seed en de frequentie- en aanwezigheidsstraffen worden doorgegeven aan het model.

Tool calling en JSON-modus

Twee functies beslissen of een model past in een echte applicatie: het aanroepen van je functies en het retourneren van gegevens die je kunt parseren. Beide worden ondersteund.

Function calling

Je declareert tools met tools, forceer optioneel een keuze met tool_choice en stuur resultaten terug als berichten met role: "tool". Gestreamde antwoorden leveren tool_calls in stukken op, zoals bij het standaardformaat.

Copyimport json
from openai import OpenAI

client = OpenAI(base_url="https://api.openaigatewayapi.com/v1", api_key="paste-your-key-here")

tools = [{
    "type": "function",
    "function": {
        "name": "get_order_status",
        "description": "Look up the status of an order by its ID.",
        "parameters": {
            "type": "object",
            "properties": {"order_id": {"type": "string"}},
            "required": ["order_id"],
        },
    },
}]

messages = [{"role": "user", "content": "Where is order A-1042?"}]
first = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
msg = first.choices[0].message

if msg.tool_calls:
    call = msg.tool_calls[0]
    args = json.loads(call.function.arguments)
    result = {"order_id": args["order_id"], "status": "shipped"}  # your real lookup here
    messages.append(msg)
    messages.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(result)})
    final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
    print(final.choices[0].message.content)

Valideer altijd de argumenten voordat je ze gebruikt. Het model produceert JSON die overeenkomt met je schema de meeste keren, niet elke keer, dus behandel call.function.arguments als elke andere onbetrouwbare invoer.

JSON-modus

Voor extractie- en classificatietaken vraag je om een JSON-object en vermeld je dit ook in de prompt. Het vermelden van JSON in de instructies geeft betere resultaten dan alleen op de vlag vertrouwen.

Copyfrom openai import OpenAI
import json

client = OpenAI(base_url="https://api.openaigatewayapi.com/v1", api_key="paste-your-key-here")

resp = client.chat.completions.create(
    model="uncensored",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": "Reply with JSON only: {\"sentiment\": string, \"topics\": [string]}."},
        {"role": "user", "content": "The docs are clear but the rate limits caught me off guard."},
    ],
)
data = json.loads(resp.choices[0].message.content)
print(data)

Limieten, fouten en retries

Een volledige sleutel staat 8 lopende verzoeken en 300 verzoeken per minuut toe. De proefsleutel staat 2 lopende verzoeken en 60 per minuut toe. De maximale verzoekbody is 8 MB. Ga je een limiet voorbij, dan krijg je HTTP 429, en de foutcode vertelt je welke limiet het was.

Error code	Betekenis	Wat te doen
rate_limited	Te veel verzoeken per minuut	Vertraag de producent of verdeel werk over de minuut
concurrency	Te veel verzoeken tegelijk	Verlaag je worker-aantal naar 8 of minder, of 2 op een proefsleutel
429 met Retry-After: 5	Tijdelijke overbelasting	Wacht de opgegeven seconden en probeer het opnieuw

De SDK's proberen sommige fouten al opnieuw. Voeg je eigen afhandeling voor 429 toe zodat een burst geen batchjob laat crashen:

Copyimport time
from openai import OpenAI, RateLimitError

client = OpenAI(
    base_url="https://api.openaigatewayapi.com/v1",
    api_key="paste-your-key-here",
    max_retries=0,
)

def ask(prompt, attempts=5):
    for i in range(attempts):
        try:
            r = client.chat.completions.create(
                model="uncensored",
                messages=[{"role": "user", "content": prompt}],
            )
            return r.choices[0].message.content
        except RateLimitError as e:
            wait = float(e.response.headers.get("retry-after", 2 ** i))
            time.sleep(wait)
    raise RuntimeError("still rate limited after retries")

Mislukte of geweigerde verzoeken worden niet in rekening gebracht, dus een retry-lus verdubbelt je rekening niet. Een semaphore die is afgestemd op je concurrency-limiet is de schoonste manier om onder de cap te blijven in async-code.

Een bestaande app erover verplaatsen

Als je een werkende app hebt, hardcodeer de nieuwe waarden dan niet. Zet de base URL, sleutel en modelnaam in omgevingsvariabelen zodat je tussen omgevingen kunt schakelen zonder een deploy. Dat stelt je ook in staat dezelfde testsuite tegen twee backends uit te voeren en de output naast elkaar te vergelijken.

Copyimport os
from openai import OpenAI

client = OpenAI(
    base_url=os.environ.get("LLM_BASE_URL", "https://api.openaigatewayapi.com/v1"),
    api_key=os.environ["LLM_API_KEY"],
)
MODEL = os.environ.get("LLM_MODEL", "uncensored")

def complete(messages, **kw):
    return client.chat.completions.create(model=MODEL, messages=messages, **kw)

Werk vervolgens een korte migratieroutine door:

1. Voer je bestaande promptset uit tegen de nieuwe endpoint en lees de outputs zelf. Geautomatiseerde checks vangen formatbreuken op, niet de toon.
2. Controleer of elke code die JSON parseert nog steeds werkt met response_format ingesteld, en houd een fallback aan die losse tekst rond het object verwijdert.
3. Meet de echte tokenaantallen uit usage, omdat een ander model tekst anders tokeniseert en je oude schattingen mogelijk niet kloppen.
4. Stel je worker pool in op 8 of minder zodat de concurrency-cap nooit het eerste ding is dat faalt onder belasting.
5. Rol uit naar een klein deel van het verkeer, observeer het 429-tarief en de errorlogs, en verbreed dan.

Teams vergeten vaak de system prompt in dit proces. Prompts die zijn geschreven om een model dat geneigd is tot weigeringen zachtjes te overtuigen tot gedrag, bevatten meestal voorzichtige zinnen die hier onnodig zijn en de output kunnen verwarren. Lees je prompt opnieuw en verwijder wat niet langer iets doet.

Wat je moet weten voordat je overschakelt

Compatibiliteit dekt het request- en responseformaat. Het maakt dit niet tot de officiële API van elke modelmaker. De service draait één open-weight model, gehost door een onafhankelijke provider en afgestemd om te antwoorden zonder contentweigeringen voor legaal gebruik door volwassenen. Het is geen router tussen leveranciers, dus je zult geen menu van andere modellen erachter vinden. Seksuele inhoud met minderjarigen is niet toegestaan, en die limiet kan niet worden gewijzigd.

Plan rond drie praktische verschillen met een groot multi-model platform:

• Eén model. De ID is uncensored. Als je code van model wisselt op basis van taak, voeg dat dan samen tot één waarde.
• Alleen tekst. Verwijder alle afbeeldings-, audio- of embedding-aanroepen uit het pad dat naar deze endpoint gaat.
• Promptgedrag verschilt. Een ander model leest instructies anders, dus voer je prompts en tests opnieuw uit na het schakelen. Scherp system prompts aan waar de output afdrijft.

Prompts worden niet gebruikt voor training. Voor de volledige parameterlijst zie de API-documentatie. Als je je uitgaven inschat, geeft de prijzenpagina de tarieven per token weer: $0,15 per 1M inputtokens en $0,50 per 1M outputtokens, gefactureerd van prepaid tegoed zonder abonnement. Opwaarderingen lopen van $20 tot $500 en tegoed vervalt niet. Als je in plaats daarvan een proxy-laag voor meerdere diensten overweegt, behandelt de pagina over LLM-gateways wanneer dat extra onderdeel zich terugverdient.

Meer handleidingen

• OpenAI Gateway API uitgelegd in gewone termen
• OpenAI Gateway API Prijzen: Echte kostenvoorbeelden
• LLM Gateway: Kosten vs. Complexiteitsanalyse