NL ▾
API-sleutel aanvragen

OpenAI-compatibele endpoint voor OpenRouter-clients

Een OpenRouter OpenAI-compatibele endpoint is gewoon een base URL die het OpenAI-chatformaat spreekt, dus het vervangen door een andere kost slechts een paar regels. Hier zijn de exacte waarden, de verzoekstructuren en de fouten die je kunt tegenkomen.

Bijgewerkt

Een enkele kabel die een terminal verbindt met een gloeiende modelkubus, die een verwisselde API-endpoint voorstelt

Belangrijkste punten

  • De base URL is https://api.openrouteralternativeapi.com/v1 en de model ID is uncensored.
  • Authenticatie is een standaard Bearer-header; alleen POST /v1/chat/completions en GET /v1/models bestaan.
  • Streaming, tools en JSON-modus werken, maar router-specifieke velden worden niet ondersteund.
  • Bij HTTP 429 lees je de foutcode om een rate limit van een concurrency limit te onderscheiden.

De waarden die je nodig hebt

Elke tool die je in staat stelt een OpenAI-stijl endpoint te bewerken, vereist drie waarden. Kopieer ze uit de tabel en niets anders verandert in een OpenAI-stijl endpoint.

InstellingWaarde
Basis-URLhttps://api.openrouteralternativeapi.com/v1
API-sleutelGemaakt op de API-sleutelpagina
Model-IDuncensored
Auth-headerAuthorization: Bearer YOUR_API_KEY
ChatroutePOST /v1/chat/completions
Model lijst routeGET /v1/models

De basis-URL eindigt al met /v1. De meeste SDK's voegen /chat/completions zelf toe, dus voeg het niet twee keer toe. Sommige tools vragen om de volledige chatroute; gebruik in dat geval de basis-URL gevolgd door /chat/completions.

Wat de endpoint wel en niet is

Achter de URL zit één open-weight model, gerund door een onafhankelijke provider en afgestemd om te antwoorden zonder inhoudelijke weigeringen voor wettelijk volwassen gebruik. Het is geen router, dus een verzoek wordt nooit doorgestuurd naar een andere leverancier. Het is ook niet de officiële API van een modelfabrikant. Dit is belangrijk voor de configuratie: er is geen lijst met modelslug om uit te kiezen, geen veld voor leveranciervoorkeur en geen fallback chain. Je stuurt uncensored en je krijgt dat ene model.

De service is alleen tekst. Afbeeldingen genereren, audio, video, embeddings en fine-tuning worden niet aangeboden, dus een client die /v1/embeddings of een afbeeldingenroute aanroept, zal falen op deze basis-URL. Houd die calls gericht op de service die je daarvoor al gebruikt, en stel de basis-URL per feature in in plaats van globaal als je applicatie meerdere mixt.

Een ander compatibiliteitspunt betreft de modellenlijst. Een client die bij het opstarten GET /v1/models aanroept om een dropdown te vullen of een instelling te valideren, krijgt het ene model terug. Dat is verwacht. Als je code controleert of een geconfigureerde modelnaam in de lijst voorkomt, stel dan de naam in op uncensored en de check slaagt. Als je applicatie diep in een configuratiebestand ergens een vendor-modelnaam hardcodeert, zoek dan in de repository naar die string voordat je de eerste run uitvoert, omdat een achtergebleven string de meest voorkomende reden is dat een gemigreerde applicatie nog steeds faalt nadat de URL is gewijzigd.

Eerste verzoek, drie manieren

Begin met een verzoek vanaf de terminal. Het bewijst de sleutel, de URL en de model-ID voordat een framework betrokken is.

curl https://api.openrouteralternativeapi.com/v1/models   -H "Authorization: Bearer $API_KEY"

curl https://api.openrouteralternativeapi.com/v1/chat/completions   -H "Authorization: Bearer $API_KEY"   -H "Content-Type: application/json"   -d '{
    "model": "uncensored",
    "messages": [{"role": "user", "content": "Reply with the word ready."}],
    "max_tokens": 10
  }'

Dezelfde aanroep met de Python SDK. Merk op dat er niets verschilt met base_url en api_key ten opzichte van standaard OpenAI-code.

from openai import OpenAI

client = OpenAI(
    base_url="https://api.openrouteralternativeapi.com/v1",
    api_key="YOUR_API_KEY",
)

r = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Reply with the word ready."}],
    max_tokens=10,
)
print(r.choices[0].message.content)
print(r.usage)

En met Node, het lezen van de sleutel uit een omgevingsvariabele:

import OpenAI from "openai";

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

const r = await client.chat.completions.create({
  model: "uncensored",
  messages: [{ role: "user", content: "Reply with the word ready." }],
  max_tokens: 10,
});
console.log(r.choices[0].message.content);

Veel tools lezen omgevingsvariabelen in plaats van constructorargumenten. De officiële SDK's honoreren vaak OPENAI_BASE_URL en OPENAI_API_KEY, wat je in staat stelt een ongewijzigd script te doorverwijzen. Controleer de documentatie van je SDK-versie om de namen te bevestigen.

Streaming, tools en JSON-modus

De features waar de meeste clients op vertrouwen zijn aanwezig. Stel stream: true in om server-sent events te ontvangen; gebruik wordt aan het einde van de stream gerapporteerd. Tool calling accepteert tools en tool_choice, streams tool_calls deltas, en verwacht resultaten terug als berichten met role: "tool". JSON-modus wordt ingeschakeld met response_format: {"type":"json_object"}. De samplingvelden temperature, top_p, stop, seed en de frequentie- en aanwezigheidsstraffen worden doorgestuurd.

Een streaming voorbeeld in Python:

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write three short taglines for a coffee cart."}],
    stream=True,
)
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

En JSON-modus, wat de moeite waard is om te combineren met een instructie in de prompt die de sleutels noemt die je verwacht:

r = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "Return JSON with keys title and tags (array of strings)."},
        {"role": "user", "content": "Summarise: a guide to brewing cold coffee at home."},
    ],
    response_format={"type": "json_object"},
)
print(r.choices[0].message.content)

Parse het resultaat altijd in een try-blok. JSON-modus verhoogt de kansen op geldige output, maar je code moet nog steeds een ongeldige reactie afhandelen, bijvoorbeeld door één keer te proberen.

Multi-turn chats en tool calls

Het endpoint is stateless, zoals de OpenAI-chatroute. Het onthoudt eerdere calls niet, dus elk verzoek moet de conversatie bevatten die je het model wilt laten zien. Houd een lijst van messages bij, voeg de assistant reply na elke turn toe, en stuur de hele lijst opnieuw. Let op het totaal: het 100.000-tokenvenster dekt prompt plus completion, en lange histories zijn ook wat de inputkost stuurt.

history = [{"role": "system", "content": "You answer in two sentences."}]

def chat(text):
    history.append({"role": "user", "content": text})
    r = client.chat.completions.create(model="uncensored", messages=history)
    reply = r.choices[0].message.content
    history.append({"role": "assistant", "content": reply})
    return reply

Voor tool calling beschrijf je je functies in tools, voer uit wat het model vraagt, en stuur de output terug als een role: "tool" message die de matching tool_call_id draagt. Een minimale definitie ziet er zo uit:

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

r = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Where is order 1042?"}],
    tools=tools,
    tool_choice="auto",
)
call = r.choices[0].message.tool_calls[0]
print(call.function.name, call.function.arguments)

Valideer de argumenten voordat je iets uitvoert. Het model stelt een call voor; je code beslist of het veilig is om uit te voeren, vooral als de functie geld, bestanden of data van anderen raakt.

Velden om te verwijderen uit OpenRouter-style requests

Clients geschreven voor een router voegen vaak extra's toe aan het request body of headers. Typische voorbeelden zijn provider ordering, model fallback arrays, routing preferences en attribution headers. Deze API gebruikt ze niet. Onbekende velden kunnen worden genegeerd of kunnen een fout veroorzaken, afhankelijk van het veld, dus strip ze in plaats van te vertrouwen op een van beide uitkomsten.

  • Vervang elke model slug die een vendor prefix bevat door uncensored.
  • Verwijder fallback lijsten. Als het enkele model niet beschikbaar is, verwerk dit in je eigen retry logica.
  • Stuur geen image of audio content parts. Het model leest tekst.
  • Houd het totale request body onder 8 MB.

De docs pagina toont de parameters die worden ondersteund, en het is de plek om te controleren wanneer een veld zich anders gedraagt dan je client verwacht.

Limieten en de 429-responses

Een volledige sleutel staat 8 gelijktijdige verzoeken en 300 verzoeken per minuut toe; een trial sleutel staat 2 en 60 toe. Elke response draagt X-Request-Id, X-Balance-USD, X-RateLimit-Limit-Requests en X-RateLimit-Limit-Concurrency. Log de request ID bij elke failure, omdat het het eerste is wat support zal vragen.

Er zijn drie soorten HTTP 429. De error code rate_limited betekent dat je de requests per minuut hebt overschreden: vertraag. De code concurrency betekent dat er te veel requests tegelijk in flight zijn: queue ze. Een 429 met een Retry-After: 5 header betekent tijdelijke overbelasting: wacht vijf seconden en probeer het opnieuw. Onthoud dat een gestreamd verzoek zijn concurrency slot vasthoudt tot de stream eindigt, dus een gestalled client die nooit tot het einde leest, zal capaciteit opeten.

import time
from openai import OpenAI, RateLimitError

client = OpenAI(
    base_url="https://api.openrouteralternativeapi.com/v1",
    api_key="YOUR_API_KEY",
    max_retries=0,
)

def ask(prompt, tries=4):
    for i in range(tries):
        try:
            r = client.chat.completions.create(
                model="uncensored",
                messages=[{"role": "user", "content": prompt}],
            )
            return r.choices[0].message.content
        except RateLimitError as e:
            wait = 5 if i == 0 else 5 * (i + 1)
            time.sleep(wait)
    raise RuntimeError("still rate limited")

Stel ook een semaphore van 8 of minder in rond calls als je workers parallel uitvoert. Dat is goedkoper dan de limit leren van errors. Voeg een beetje random jitter toe aan de wait zodat meerdere workers die samen falen, niet allemaal in hetzelfde second retryen. Als je herhaalde 429-responses ziet bij laag verkeer, zoek dan naar streams die open zijn maar nooit worden gesloten, of een retry loop die afvuurt zonder te wachten, omdat elk van beide de beschikbare slots op zichzelf kan vullen.

Controleer de kosten voordat je productie erop wijst

Prijzen zijn $0,15 per 1M input tokens en $0,50 per 1M output tokens van prepaid credit. Neem een verzoek met 2.000 input tokens en 500 output tokens. Input kost 2.000 / 1.000.000 x $0,15 = $0,0003. Output kost 500 / 1.000.000 x $0,50 = $0,00025. Het verzoek kost $0,00055, dus 1.000 van zulke verzoeken kosten $0,55. Mislukte of geweigerde verzoeken worden niet in rekening gebracht. Zie de prijspagina voor top-up bedragen en bonussen; het gratis proeftegoed van $0,50 dekt ongeveer 900 verzoeken van die grootte (0,50 / 0,00055).

Vragen en antwoorden

Wat is de base URL voor de OpenAI-compatibele endpoint?

Gebruik https://api.openrouteralternativeapi.com/v1 als base URL en stuur je sleutel als Bearer-token. De model-ID is uncensored.

Welke routes zijn beschikbaar?

POST /v1/chat/completions voor generatie en GET /v1/models voor de modellijst. Er zijn geen embeddings-, afbeeldings-, audio- of fine-tuningroutes.

Moet ik mijn code aanpassen behalve de URL en sleutel?

Meestal alleen de modelstring. Verwijder router-specifieke velden zoals providervoorkeuren of fallback-lijsten uit request-lichamen.

Waarom krijg ik HTTP 429?

Controleer de foutcode. rate_limited betekent te veel verzoeken per minuut, concurrency betekent te veel tegelijk, en een Retry-After: 5-header betekent tijdelijke overbelasting.

Je sleutel is nog maar één formulier verwijderd

Maak een account aan, kopieer de sleutel, pas de base URL aan. Dat is de hele setup.