Compatible OpenAI et Anthropic

Une seule URL de base. Tous les modèles.

Branchez n'importe quel SDK OpenAI ou Anthropic sur unbottled.ai. Codex CLI et Claude Code aussi. 126 modèles de chat, streaming, appels d'outils. Images, voix, vidéo et musique avec la même clé. Aucun nouveau client à apprendre.

Démarrage rapide

Appelez un modèle en 60 secondes

L'API parle le format d'échange d'OpenAI et celui d'Anthropic. Si votre code tourne avec l'un des deux, il tourne ici après deux changements : l'URL de base et la clé.

Compte payant requis. Les clés et les appels /v1 nécessitent un compte payant : n'importe quelle formule, dès €8 par mois. Les comptes gratuits peuvent créer des clés et lire cette documentation, mais chaque appel renvoie HTTP 402 paid_plan_required jusqu'au premier achat. Les crédits gratuits et les crédits bonus ne débloquent pas l'API. Chaque formule inclut des crédits mensuels. Besoin de plus ? Les abonnés rechargent avec des packs de crédits qui n'expirent jamais.

Débloquer l'API

1

Obtenez une clé

Créez une clé sk-unb dans Paramètres > Clés API. Elle n'est affichée qu'une fois.

URL de base: https://unbottled.ai/api/fr-FR/v1

Toute locale fonctionne dans le chemin (en-US, de-DE, pl-PL). Elle ne change que la langue des messages d'erreur.

URL de base Anthropic: https://unbottled.ai/api/fr-FR

Pour Claude Code et les SDK Anthropic. Même URL sans /v1 : ils ajoutent eux-mêmes /v1/messages.

2

Envoyez une requête

Du HTTP simple. Fonctionne depuis n'importe quel langage.

curl
curl https://unbottled.ai/api/fr-FR/v1/chat/completions \
  -H "Authorization: Bearer sk-unb-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k3.1-pro",
    "messages": [
      { "role": "system", "content": "You answer in one sentence." },
      { "role": "user", "content": "Why is the sky blue?" }
    ]
  }'
3

Ou utilisez un SDK OpenAI

Changez baseURL et apiKey. Rien d'autre.

Python
from openai import OpenAI

client = OpenAI(
    base_url="https://unbottled.ai/api/fr-FR/v1",
    api_key="sk-unb-YOUR_KEY",
)

reply = client.chat.completions.create(
    model="kimi-k3.1-pro",
    messages=[{"role": "user", "content": "Why is the sky blue?"}],
)
print(reply.choices[0].message.content)
Node.js
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://unbottled.ai/api/fr-FR/v1",
  apiKey: process.env.UNBOTTLED_API_KEY, // sk-unb-YOUR_KEY
});

const reply = await client.chat.completions.create({
  model: "kimi-k3.1-pro",
  messages: [{ role: "user", content: "Why is the sky blue?" }],
});
console.log(reply.choices[0].message.content);
Authentification

Authentification

Envoyez votre clé comme jeton Bearer à chaque requête. Les clés commencent par sk-unb-. Les clients Anthropic l'envoient dans x-api-key, ce qui fonctionne aussi.

header
Authorization: Bearer sk-unb-YOUR_KEY
header
x-api-key: sk-unb-YOUR_KEY

Nous stockons une empreinte (hash), pas la clé. Si vous la perdez, créez-en une nouvelle.

Une clé fonctionne uniquement sur l'API : /v1/models, chat (/v1/chat/completions, /v1/responses, /v1/messages) et médias (/v1/images, /v1/audio, /v1/videos, /v1/music, /v1/media). Elle ne peut pas toucher à votre compte, à vos paiements ni à vos paramètres.

Jusqu'à 20 clés actives par compte. Révoquez une clé à tout moment : elle cesse aussitôt de fonctionner.

Sans clé ou avec une clé révoquée, la réponse est 401. Une clé dont le compte n'a pas de formule payante renvoie 402.

Modèles

GET /v1/models

Liste les modèles que votre clé peut appeler maintenant, avec la taille du contexte, la prise en charge des outils et le prix en crédits par million de tokens. Utilisez l'id comme champ model dans vos requêtes.

request
curl https://unbottled.ai/api/fr-FR/v1/models \
  -H "Authorization: Bearer sk-unb-YOUR_KEY"
200
{
  "object": "list",
  "data": [
    {
      "id": "kimi-k3.1-pro",
      "object": "model",
      "created": 1735689600,
      "owned_by": "moonshot",
      "name": "Kimi K3.1 Pro",
      "context_length": 131072,
      "supports_tools": true,
      "input_modalities": ["text"],
      "output_modalities": ["text"],
      "pricing": {
        "input_credits_per_million_tokens": 8,
        "output_credits_per_million_tokens": 32
      }
    }
  ]
}

La liste dépend de votre compte. Les ids inconnus ou indisponibles renvoient 404 model_not_found. Une seule correspondance : sur /v1/messages, les ids Claude que Claude Code envoie par défaut pointent vers notre Claude le plus récent de la même famille.

Les modèles média dans la même liste

Modèles d'image, de vidéo, de musique, de voix et de transcription figurent dans la même liste. Chaque entrée dit ce que fait le modèle et où l'appeler.

entrée média
{
  "id": "flux-3-klein",
  "object": "model",
  "owned_by": "blackForestLabs",
  "modality": "image",
  "endpoints": ["/v1/images/generations", "/v1/images/edits"],
  "input_modalities": ["text", "image"],
  "output_modalities": ["image"],
  "pricing": { "credits_per_image": 1.17 }
}

modality vaut chat, image, video, music, speech ou transcription. endpoints liste les chemins qui acceptent le modèle.

Les prix média sont à l'unité : credits_per_image, credits_per_second (vidéo), credits_per_clip (musique), credits_per_1k_characters (voix), credits_per_minute (transcription).

Les clients Anthropic (en-tête anthropic-version) ne reçoivent que les modèles de chat. Les modèles dont le fournisseur n'est pas configuré chez nous ne sont pas listés et répondent 404 model_not_found.

Chat completions

POST /v1/chat/completions

Les chat completions OpenAI standard. Des messages en entrée, un message de l'assistant en sortie. Entrées texte et image (image_url en URL https ou en data URL base64).

Sans streaming

Le mode par défaut. Vous recevez un seul corps JSON quand le modèle a terminé. usage.credits_charged indique ce que cet appel vous a coûté.

request
curl https://unbottled.ai/api/fr-FR/v1/chat/completions \
  -H "Authorization: Bearer sk-unb-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k3.1-pro",
    "messages": [
      { "role": "system", "content": "You answer in one sentence." },
      { "role": "user", "content": "Why is the sky blue?" }
    ]
  }'
200
{
  "id": "chatcmpl-3f9c1a...",
  "object": "chat.completion",
  "created": 1767225600,
  "model": "kimi-k3.1-pro",
  "choices": [
    {
      "index": 0,
      "message": { "role": "assistant", "content": "Air scatters blue light more than red." },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 31,
    "completion_tokens": 9,
    "total_tokens": 40,
    "credits_charged": 0.1
  }
}

Streaming

Passez stream: true pour recevoir des server-sent events au format chunk d'OpenAI, terminés par data: [DONE]. Ajoutez stream_options.include_usage pour obtenir un dernier chunk avec le nombre de tokens et credits_charged. Fermer la connexion arrête la génération. Vous ne payez que ce qui a tourné.

request
curl -N https://unbottled.ai/api/fr-FR/v1/chat/completions \
  -H "Authorization: Bearer sk-unb-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k3.1-pro",
    "stream": true,
    "stream_options": { "include_usage": true },
    "messages": [{ "role": "user", "content": "Count to three." }]
  }'
200
data: {"id":"chatcmpl-3f9c...","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}]}

data: {"id":"chatcmpl-3f9c...","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":"One, "},"finish_reason":null}]}

data: {"id":"chatcmpl-3f9c...","object":"chat.completion.chunk","choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}

data: {"id":"chatcmpl-3f9c...","object":"chat.completion.chunk","choices":[],"usage":{"prompt_tokens":12,"completion_tokens":7,"total_tokens":19,"credits_charged":0.1}}

data: [DONE]
Python
stream = client.chat.completions.create(
    model="kimi-k3.1-pro",
    messages=[{"role": "user", "content": "Count to three."}],
    stream=True,
)
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")
Node.js
const stream = await client.chat.completions.create({
  model: "kimi-k3.1-pro",
  messages: [{ role: "user", content: "Count to three." }],
  stream: true,
});
for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}

Champs de la requête

ChampRôle
modelObligatoire. Un id de modèle issu de GET /v1/models.
messagesObligatoire. Messages system, developer, user, assistant et tool. Le contenu user peut être une chaîne ou des parties text et image_url.
streamtrue pour les server-sent events. false par défaut.
stream_options{ include_usage: true } ajoute un dernier chunk d'usage.
max_tokensPlafond de tokens générés. max_completion_tokens est prioritaire. Limité à 32768.
temperatureDe 0 à 2. Ignoré par les modèles qui ne le prennent pas en charge.
top_pDe 0 à 1.
stopUne chaîne d'arrêt ou une liste de chaînes.
nSeul 1 est pris en charge. Toute autre valeur renvoie 400.
toolsLes fonctions que le modèle peut appeler. Voir Appels d'outils.
tool_choicenone, auto, required, ou une fonction nommée.
Appels d'outils

Appels d'outils

Le function calling fonctionne comme chez OpenAI. Vous décrivez des fonctions, le modèle décide d'en appeler une, vous l'exécutez et renvoyez le résultat. Nous n'exécutons jamais vos outils.

La boucle

Envoyez tools avec vos messages.

Le modèle répond avec tool_calls et finish_reason: tool_calls. Chaque appel a un id, un nom de fonction et des arguments sous forme de chaîne JSON.

Exécutez vous-même la fonction. Ajoutez le message de l'assistant, puis un message tool par appel avec son tool_call_id.

Rappelez l'API. Le modèle utilise les résultats et répond.

1. Requête avec outils

request
curl https://unbottled.ai/api/fr-FR/v1/chat/completions \
  -H "Authorization: Bearer sk-unb-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k3.1-pro",
    "messages": [{ "role": "user", "content": "Weather in Berlin?" }],
    "tools": [{
      "type": "function",
      "function": {
        "name": "get_weather",
        "description": "Current weather for a city",
        "parameters": {
          "type": "object",
          "properties": { "city": { "type": "string" } },
          "required": ["city"]
        }
      }
    }],
    "tool_choice": "auto"
  }'

2. Le modèle demande un appel

200
{
  "object": "chat.completion",
  "model": "kimi-k3.1-pro",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": null,
        "tool_calls": [
          {
            "id": "call_8x2k",
            "type": "function",
            "function": { "name": "get_weather", "arguments": "{\"city\":\"Berlin\"}" }
          }
        ]
      },
      "finish_reason": "tool_calls"
    }
  ]
}

3. Renvoyez le résultat

request
# Run get_weather yourself, then send the result back:
curl https://unbottled.ai/api/fr-FR/v1/chat/completions \
  -H "Authorization: Bearer sk-unb-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k3.1-pro",
    "messages": [
      { "role": "user", "content": "Weather in Berlin?" },
      { "role": "assistant", "content": null, "tool_calls": [
        { "id": "call_8x2k", "type": "function",
          "function": { "name": "get_weather", "arguments": "{\"city\":\"Berlin\"}" } }
      ]},
      { "role": "tool", "tool_call_id": "call_8x2k", "content": "18C, cloudy" }
    ],
    "tools": [ ...same tools as before... ]
  }'

La même boucle avec le SDK Python

Python
import json

tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Current weather for a city",
        "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"],
        },
    },
}]
messages = [{"role": "user", "content": "Weather in Berlin?"}]

first = client.chat.completions.create(
    model="kimi-k3.1-pro", messages=messages, tools=tools
)
call = first.choices[0].message.tool_calls[0]
result = get_weather(**json.loads(call.function.arguments))  # your code

messages += [
    first.choices[0].message,
    {"role": "tool", "tool_call_id": call.id, "content": result},
]
final = client.chat.completions.create(
    model="kimi-k3.1-pro", messages=messages, tools=tools
)
print(final.choices[0].message.content)

Appels d'outils en streaming

Avec stream: true, les appels arrivent sous forme de chunks delta.tool_calls, repérés par index. Le premier chunk d'un index porte id et function.name. Les chunks suivants complètent function.arguments. Concaténez-les, puis parsez le JSON quand finish_reason vaut tool_calls. Tous les SDK OpenAI le font pour vous.

Règles

Le modèle doit prendre en charge les outils : vérifiez supports_tools dans GET /v1/models. Les autres renvoient 400 tools_not_supported.

tool_choice none, auto et required fonctionnent comme chez OpenAI. Nommer une fonction absente de tools renvoie 400.

Noms de fonction : lettres, chiffres, tiret bas, tiret, 64 caractères maximum.

Les définitions et les résultats d'outils sont des tokens d'entrée. Les appels sont des tokens de sortie. Ils sont facturés comme tous les autres tokens.

Responses API

POST /v1/responses

La Responses API d'OpenAI, le format que parle Codex CLI. Mêmes modèles, même clé, mêmes crédits et mêmes limites de débit que les chat completions.

Requête

input est une chaîne ou une liste d'éléments d'entrée. instructions est le prompt système. La réponse arrive sous forme d'éléments de sortie. Tous les SDK OpenAI fournissent aussi output_text.

request
curl https://unbottled.ai/api/fr-FR/v1/responses \
  -H "Authorization: Bearer sk-unb-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k3.1-pro",
    "instructions": "You answer in one sentence.",
    "input": "Why is the sky blue?"
  }'
200
{
  "id": "resp_7d2e...",
  "object": "response",
  "status": "completed",
  "model": "kimi-k3.1-pro",
  "output": [
    {
      "type": "message",
      "role": "assistant",
      "content": [
        { "type": "output_text", "text": "Air scatters blue light more than red." }
      ]
    }
  ],
  "usage": { "input_tokens": 24, "output_tokens": 9, "total_tokens": 33 }
}

Streaming

Passez stream: true pour le flux d'événements Responses : response.created, les deltas de texte, puis response.completed avec l'usage.

200
event: response.created
data: {"type":"response.created","response":{"id":"resp_7d2e...","status":"in_progress"}}

event: response.output_text.delta
data: {"type":"response.output_text.delta","delta":"Air scatters "}

event: response.completed
data: {"type":"response.completed","response":{"id":"resp_7d2e...","status":"completed"}}

Avec le SDK Python d'OpenAI

Python
reply = client.responses.create(
    model="kimi-k3.1-pro",
    input="Why is the sky blue?",
)
print(reply.output_text)

Outils : function, custom et local_shell. Les appels du modèle reviennent sous forme d'éléments de sortie. Renvoyez chaque résultat comme élément function_call_output avec le même call_id.

Les modèles de raisonnement renvoient des éléments reasoning à côté de la réponse.

La facturation, les ids de modèle, les erreurs et les limites de débit fonctionnent exactement comme pour les chat completions.

Messages API

POST /v1/messages

La Messages API d'Anthropic, le format que parlent Claude Code et les SDK Anthropic. Utilisez l'URL de base sans /v1 : les clients ajoutent eux-mêmes /v1/messages.

Requête

Requête Messages standard : model, max_tokens, system, messages. Blocs texte et image en entrée, blocs texte et tool_use en sortie.

request
curl https://unbottled.ai/api/fr-FR/v1/messages \
  -H "x-api-key: sk-unb-YOUR_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k3.1-pro",
    "max_tokens": 1024,
    "system": "You answer in one sentence.",
    "messages": [{ "role": "user", "content": "Why is the sky blue?" }]
  }'
200
{
  "id": "msg_01Hk...",
  "type": "message",
  "role": "assistant",
  "model": "kimi-k3.1-pro",
  "content": [{ "type": "text", "text": "Air scatters blue light more than red." }],
  "stop_reason": "end_turn",
  "usage": { "input_tokens": 24, "output_tokens": 9 }
}

Streaming

Passez stream: true pour les server-sent events d'Anthropic, de message_start à message_stop.

200
event: message_start
data: {"type":"message_start","message":{"id":"msg_01Hk...","role":"assistant","content":[]}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Air scatters "}}

event: message_stop
data: {"type":"message_stop"}

Avec le SDK Python d'Anthropic

Python
import anthropic

client = anthropic.Anthropic(
    base_url="https://unbottled.ai/api/fr-FR",
    api_key="sk-unb-YOUR_KEY",
)

reply = client.messages.create(
    model="kimi-k3.1-pro",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Why is the sky blue?"}],
)
# Reasoning models put a thinking block first: print the text block.
print(next(block.text for block in reply.content if block.type == "text"))

POST /v1/messages/count_tokens

Compte les tokens d'entrée d'une requête Messages sans faire tourner le modèle. Claude Code l'appelle pour gérer son contexte.

request
curl https://unbottled.ai/api/fr-FR/v1/messages/count_tokens \
  -H "x-api-key: sk-unb-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-5-20250929",
    "messages": [{ "role": "user", "content": "Why is the sky blue?" }]
  }'
200
{ "input_tokens": 14 }

Authentification : x-api-key ou Authorization: Bearer. Les deux acceptent votre clé sk-unb.

Modèle : n'importe quel id de GET /v1/models. Les ids Anthropic que Claude Code envoie par défaut, comme claude-sonnet-4-5-20250929, pointent vers notre modèle Claude correspondant.

Outils : blocs tool_use en sortie, blocs tool_result en retour, comme dans l'API Anthropic.

Mêmes crédits, mêmes prix, mêmes limites de débit que tous les autres endpoints.

Images

POST /v1/images/generations

Format d'images OpenAI. N'importe quel modèle avec modality image dans GET /v1/models. Fonctionne avec le client images de chaque SDK OpenAI.

Générer

model, prompt, n (1 à 4), size en LARGEURxHAUTEUR ou auto, quality. aspect_ratio est notre extension et prime sur size. response_format url (par défaut) ou b64_json.

request
curl https://unbottled.ai/api/fr-FR/v1/images/generations \
  -H "Authorization: Bearer sk-unb-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "flux-3-klein",
    "prompt": "A lighthouse on a cliff at dawn, oil painting",
    "size": "1024x1024",
    "n": 1
  }'
200
{
  "created": 1767225600,
  "model": "flux-3-klein",
  "data": [
    { "url": "https://unbottled.ai/api/fr-FR/v1/media/3f9c.../image-1.png?expires=1767830400&sig=..." }
  ],
  "credits_charged": 1.17
}
Python
import base64

img = client.images.generate(
    model="flux-3-klein",
    prompt="A lighthouse on a cliff at dawn, oil painting",
    response_format="b64_json",
)
open("lighthouse.png", "wb").write(base64.b64decode(img.data[0].b64_json))

POST /v1/images/edits

Une image d'entrée plus un prompt. Envoyez-la dans le champ multipart image, ou via image_url (https ou data URL base64) en JSON. Le modèle doit accepter une image : input_modalities contient image. Les masques ne sont pas pris en charge ; décrivez la retouche dans le prompt.

request
curl https://unbottled.ai/api/fr-FR/v1/images/edits \
  -H "Authorization: Bearer sk-unb-YOUR_KEY" \
  -F model=flux-3-klein \
  -F prompt="Make it night, add a full moon" \
  -F image=@lighthouse.png

Nous choisissons la taille et le format les plus proches que le modèle produit.

url est un lien signé vers le fichier stocké, valable 7 jours sans clé. b64_json renvoie les octets directement dans la réponse.

Facturé par image. credits_charged dans la réponse indique le coût de l'appel.

Synthèse vocale

POST /v1/audio/speech

Du texte en entrée, des octets audio en sortie. model est un ID de voix de GET /v1/models (modality speech), comme openai-nova. La syntaxe OpenAI marche aussi : model tts-1 avec voice nova.

request
curl https://unbottled.ai/api/fr-FR/v1/audio/speech \
  -H "Authorization: Bearer sk-unb-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai-nova",
    "input": "Your build finished. All tests are green.",
    "response_format": "mp3"
  }' \
  -o speech.mp3
Python
# OpenAI names work too: model tts-1 plus voice nova is openai-nova.
audio = client.audio.speech.create(
    model="tts-1", voice="nova", input="Your build finished."
)
audio.write_to_file("speech.mp3")

input jusqu'à 4096 caractères. speed de 0.25 à 4 sur les voix OpenAI, NanoGPT et ElevenLabs.

response_format mp3 (par défaut), opus, aac, flac, wav ou pcm. Les formats disponibles dépendent du fournisseur de la voix ; les autres répondent 400 avec la liste.

Facturé au caractère. L'en-tête X-Credits-Charged indique le coût de l'appel.

Transcription

POST /v1/audio/transcriptions

La parole en texte, au format OpenAI Whisper. Upload multipart, le même appel SDK que vous utilisez déjà.

Transcrire

file jusqu'à 25 Mo (mp3, mp4, m4a, wav, webm, ogg, flac), model comme whisper-1, language en option. response_format json, text, srt, verbose_json ou vtt.

request
curl https://unbottled.ai/api/fr-FR/v1/audio/transcriptions \
  -H "Authorization: Bearer sk-unb-YOUR_KEY" \
  -F model=whisper-1 \
  -F file=@meeting.mp3 \
  -F response_format=json
200
{ "text": "Let's ship the release on Friday." }

POST /v1/audio/translations

N'importe quelle langue parlée en entrée, du texte anglais en sortie. Tourne sur whisper-1. Mêmes formats que la transcription.

request
curl https://unbottled.ai/api/fr-FR/v1/audio/translations \
  -H "Authorization: Bearer sk-unb-YOUR_KEY" \
  -F model=whisper-1 \
  -F file=@interview-de.mp3

Facturé à la seconde d'audio.

Vidéo

POST /v1/videos

Asynchrone, au format de l'API vidéo d'OpenAI. L'appel répond tout de suite avec une tâche. Suivez-la, puis téléchargez le MP4.

Lancer une tâche

model, prompt, seconds, size ou aspect_ratio, resolution, negative_prompt. La réponse est un objet vidéo avec status queued. Ci-dessous : le même objet une fois terminé.

request
curl https://unbottled.ai/api/fr-FR/v1/videos \
  -H "Authorization: Bearer sk-unb-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "wan-2-7-t2v",
    "prompt": "A paper boat drifting down a rainy street, cinematic",
    "seconds": 5,
    "size": "1280x720"
  }'
200
{
  "id": "video_8f2c0e5a7b1d4c3e9a6f0b2d4e6a8c1f",
  "object": "video",
  "model": "wan-2-7-t2v",
  "status": "completed",
  "progress": 100,
  "seconds": "5",
  "size": "1280x720",
  "url": "https://unbottled.ai/api/fr-FR/v1/media/7a1e.../video.mp4?expires=1767830400&sig=...",
  "credits_charged": 42,
  "error": null
}

Suivre et télécharger

GET /v1/videos/{id} renvoie status (queued, in_progress, completed, failed), progress et, une fois terminé, une url signée. Le suivi est gratuit et ne compte pas dans la limite de débit. GET /v1/videos/{id}/content envoie le MP4.

request
# Poll until status is completed or failed (free, no rate budget)
curl https://unbottled.ai/api/fr-FR/v1/videos/video_8f2c0e5a7b1d4c3e9a6f0b2d4e6a8c1f \
  -H "Authorization: Bearer sk-unb-YOUR_KEY"

# Download the MP4
curl https://unbottled.ai/api/fr-FR/v1/videos/video_8f2c0e5a7b1d4c3e9a6f0b2d4e6a8c1f/content \
  -H "Authorization: Bearer sk-unb-YOUR_KEY" \
  -o boat.mp4

Image vers vidéo : envoyez image_url en JSON ou input_reference en upload multipart. Elle devient la première image du clip.

Facturé une fois la vidéo prête, à la seconde de vidéo. credits_charged indique le coût.

Une tâche échouée ne coûte rien. error en donne la raison.

Musique

POST /v1/music

Asynchrone, comme la vidéo. Lancez la tâche, suivez GET /v1/music/{id}, téléchargez GET /v1/music/{id}/content.

request
curl https://unbottled.ai/api/fr-FR/v1/music \
  -H "Authorization: Bearer sk-unb-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "musicgen-stereo",
    "prompt": "Lo-fi hip hop, warm piano, slow vinyl crackle",
    "seconds": 20
  }'
request
curl https://unbottled.ai/api/fr-FR/v1/music/music_3b7d1f9a2c4e6a8b0d2f4a6c8e0b1d3f \
  -H "Authorization: Bearer sk-unb-YOUR_KEY"

curl https://unbottled.ai/api/fr-FR/v1/music/music_3b7d1f9a2c4e6a8b0d2f4a6c8e0b1d3f/content \
  -H "Authorization: Bearer sk-unb-YOUR_KEY" \
  -o track.mp3

seconds : environ 8, 20 ou 30. Le modèle peut arrondir. Décrivez style, ambiance, instruments et tempo dans prompt.

Facturé au clip une fois prêt. Une tâche échouée ne coûte rien.

Fichiers média

GET /v1/media/{folder}/{file}

Chaque url d'une réponse média pointe ici. Le lien signé fonctionne sans clé pendant 7 jours : donnez-le à un navigateur ou à un utilisateur. Avec votre clé API, le même chemin fonctionne à tout moment.

request
# Signed link from a response: works without a key for 7 days
curl -o image.png "https://unbottled.ai/api/fr-FR/v1/media/3f9c.../image-1.png?expires=1767830400&sig=..."

# Same file with your key, any time
curl -o image.png https://unbottled.ai/api/fr-FR/v1/media/3f9c.../image-1.png \
  -H "Authorization: Bearer sk-unb-YOUR_KEY"
Crédits et facturation

Crédits et facturation

L'API puise dans les mêmes crédits que l'app de chat, facturés selon les mêmes règles. Un seul solde, une seule facture.

Coût = tokens d'entrée plus tokens de sortie au prix en crédits du modèle, indiqué par million de tokens dans GET /v1/models. Exception : les modèles OpenRouter. Vous payez ce que le fournisseur a réellement facturé pour l'appel, plus notre marge. Leur prix affiché est une estimation. Le chat les facture de la même manière.

Chaque réponse indique usage.credits_charged. Votre solde se trouve dans l'app, sous Crédits.

Avant chaque appel, nous comparons votre solde à une estimation du pire cas. Solde insuffisant : HTTP 402 insufficient_credits, rien ne tourne, rien n'est facturé.

Après l'appel, vous payez l'usage réel, pas l'estimation : le nombre de tokens annoncé par le fournisseur, ou le coût réel du fournisseur pour les modèles OpenRouter. Si un fournisseur n'indique aucun coût, l'appel est facturé au prix affiché.

Les appels média se facturent de la même façon : le coût réel du fournisseur plus notre marge quand il le communique, sinon le prix listé du modèle. Images à l'unité, voix au caractère, transcription à la seconde d'audio, vidéo une fois le clip prêt, musique au clip.

Plus de crédits ? Rechargez avec un pack, renouvelez ou passez à une formule supérieure. L'appel suivant fonctionne immédiatement.

402
HTTP/1.1 402 Payment Required
{
  "error": {
    "message": "Insufficient credits. This call needs about 1.2, you have 0.4. Top up to continue.",
    "type": "insufficient_quota",
    "param": null,
    "code": "insufficient_credits"
  }
}
Limites de débit

Limites de débit

Chaque clé autorise par défaut 60 requêtes par minute. Au-delà, vous recevez HTTP 429 avec un en-tête Retry-After en secondes. Attendez ce délai, puis réessayez. Les limites s'appliquent par clé : répartissez les charges lourdes sur plusieurs clés.

429
HTTP/1.1 429 Too Many Requests
Retry-After: 12
{ "error": { "type": "rate_limit_error", "code": "rate_limit_exceeded", ... } }
Erreurs

Erreurs

Les erreurs utilisent l'enveloppe d'OpenAI, donc les SDK lèvent leurs exceptions habituelles. Basez votre logique sur error.code, pas sur le message.

error
{
  "error": {
    "message": "Invalid or revoked API key. ...",
    "type": "authentication_error",
    "param": null,
    "code": "invalid_api_key"
  }
}
/v1/messages
{
  "type": "error",
  "error": {
    "type": "authentication_error",
    "message": "Invalid or revoked API key. ..."
  }
}
HTTP / codeSignification
401 missing_api_keyAucune clé envoyée. Envoyez Authorization: Bearer sk-unb-..., ou x-api-key.
401 invalid_api_keyClé erronée ou révoquée.
402 paid_plan_requiredAucune formule ni aucun achat de crédits sur le compte pour l'instant. N'importe quelle formule débloque l'accès.
402 insufficient_creditsSolde insuffisant pour cet appel. Rechargez.
402 free_tier_cap_reachedLe solde payant est vide et le plafond quotidien de crédits gratuits est atteint. Rechargez.
404 model_not_foundLe modèle n'existe pas ou ne vous est pas accessible.
400 invalid_value / unsupported_parameter / tools_not_supportedRequête invalide : paramètre non pris en charge, tool_choice incorrect, URL d'image invalide.
400 content_policy_violationLe fournisseur média a refusé le prompt. Rien n'est facturé. Reformulez ou choisissez un autre modèle.
403 uncensored_consent_requiredLes modèles non censurés demandent une confirmation unique de majorité (18+) sur votre compte. Confirmez une fois dans l'app, puis relancez.
429 rate_limit_exceededPlus de 60 requêtes par minute pour cette clé. Lisez Retry-After.
502 upstream_errorLe fournisseur du modèle a échoué. Vous pouvez réessayer sans risque. Les streams se terminent par un événement d'erreur.
503 balance_unavailableImpossible de lire votre solde, donc rien n'a tourné. Réessayez.
Les erreurs survenues en cours de stream arrivent sous forme d'événement data: avec le même objet error, suivi de data: [DONE].
Outils de développement

Utilisez-la dans votre agent de code

Une URL de base, une clé. Codex CLI et Claude Code se connectent nativement. OpenCode, Continue, Aider et Cline passent par les chat completions. Copiez un bloc, exécutez-le.

Codex CLI

Collez la commande et Codex tourne sur unbottled.ai. Pour la garder, ajoutez le bloc à ~/.codex/config.toml et lancez Codex avec --profile unbottled.

Une seule commande
terminal
UNBOTTLED_API_KEY="sk-unb-YOUR_KEY" codex \
  -c 'model_providers.unbottled={name="unbottled.ai",base_url="https://unbottled.ai/api/fr-FR/v1",env_key="UNBOTTLED_API_KEY",wire_api="responses"}' \
  -c model_provider=unbottled \
  -m glm-5.3
Configuration permanente
~/.codex/config.toml
[model_providers.unbottled]
name = "unbottled.ai"
base_url = "https://unbottled.ai/api/fr-FR/v1"
env_key = "UNBOTTLED_API_KEY"
wire_api = "responses"

[profiles.unbottled]
model_provider = "unbottled"
model = "glm-5.3"
Puis lancez-le
terminal
export UNBOTTLED_API_KEY="sk-unb-YOUR_KEY"
codex --profile unbottled

Testé avec Codex CLI 0.118.0

Claude Code

Collez la commande et Claude Code tourne sur unbottled.ai. Pour la garder, placez les mêmes valeurs dans le bloc env de ~/.claude/settings.json, à côté de ce qui s'y trouve déjà. Retirez les lignes model et Claude Code utilise nos modèles Claude sous les noms qu'il connaît déjà.

Une seule commande
terminal
ANTHROPIC_BASE_URL="https://unbottled.ai/api/fr-FR" \
ANTHROPIC_AUTH_TOKEN="sk-unb-YOUR_KEY" \
ANTHROPIC_MODEL="glm-5.3" \
ANTHROPIC_DEFAULT_OPUS_MODEL="glm-5.3" \
ANTHROPIC_DEFAULT_SONNET_MODEL="glm-5.3" \
ANTHROPIC_DEFAULT_HAIKU_MODEL="glm-5.3-flash" \
CLAUDE_CODE_SUBAGENT_MODEL="glm-5.3" \
CLAUDE_CODE_MAX_CONTEXT_TOKENS="1048576" \
CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC="1" \
claude
Configuration permanente
~/.claude/settings.json
{
  "env": {
    "ANTHROPIC_BASE_URL": "https://unbottled.ai/api/fr-FR",
    "ANTHROPIC_AUTH_TOKEN": "sk-unb-YOUR_KEY",
    "ANTHROPIC_MODEL": "glm-5.3",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "glm-5.3",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "glm-5.3",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "glm-5.3-flash",
    "CLAUDE_CODE_SUBAGENT_MODEL": "glm-5.3",
    "CLAUDE_CODE_MAX_CONTEXT_TOKENS": "1048576",
    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1"
  }
}
Puis lancez-le
terminal
claude

Testé avec Claude Code 2.1.323

OpenCode

Enregistrez sous opencode.json dans votre projet, ou sous ~/.config/opencode/opencode.json pour tous vos projets. Ajoutez n'importe quel id de modèle à la table models.

Une seule commande
terminal
UNBOTTLED_API_KEY="sk-unb-YOUR_KEY" \
OPENCODE_CONFIG_CONTENT='{"provider":{"unbottled":{"npm":"@ai-sdk/openai-compatible","options":{"baseURL":"https://unbottled.ai/api/fr-FR/v1","apiKey":"{env:UNBOTTLED_API_KEY}"},"models":{"glm-5.3":{}}}},"model":"unbottled/glm-5.3"}' \
opencode
Configuration permanente
opencode.json
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "unbottled": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "unbottled.ai",
      "options": {
        "baseURL": "https://unbottled.ai/api/fr-FR/v1",
        "apiKey": "{env:UNBOTTLED_API_KEY}"
      },
      "models": {
        "glm-5.3": { "name": "GLM-5.3" },
        "claude-sonnet-5.5": { "name": "Claude Sonnet 5.5" },
        "glm-5.3-uncensored": { "name": "GLM 5.3 Uncensored" }
      }
    }
  },
  "model": "unbottled/glm-5.3"
}
Puis lancez-le
terminal
export UNBOTTLED_API_KEY="sk-unb-YOUR_KEY"
opencode

Testé avec OpenCode 1.19.5

Continue

Lance le CLI Continue. L'extension IDE lit ~/.continue/config.yaml : ajoutez-y la même entrée de modèle.

Configuration permanente
config.yaml
name: unbottled
version: 1.0.0
schema: v1
models:
  - name: GLM-5.3
    provider: openai
    model: glm-5.3
    apiBase: https://unbottled.ai/api/fr-FR/v1
    apiKey: ${{ secrets.UNBOTTLED_API_KEY }}
    roles: [chat, edit, apply]
Puis lancez-le
terminal
export UNBOTTLED_API_KEY="sk-unb-YOUR_KEY"
cn --config ./config.yaml

Testé avec Continue 1.5.47

Aider

Une seule commande. Aider attend openai/ devant l'id du modèle. Indiquez les fichiers à modifier après la commande, comme d'habitude.

Une seule commande
terminal
OPENAI_API_BASE="https://unbottled.ai/api/fr-FR/v1" \
OPENAI_API_KEY="sk-unb-YOUR_KEY" \
aider --model openai/glm-5.3 --edit-format diff --no-show-model-warnings

Testé avec Aider 0.86.2

Cline

Deux commandes avec le CLI Cline : enregistrez le fournisseur une fois, puis lancez cline.

Une seule commande
terminal
cline auth -p openai -k "sk-unb-YOUR_KEY" -b "https://unbottled.ai/api/fr-FR/v1" -m glm-5.3
Puis lancez-le
terminal
cline

Testé avec Cline 3.0.74

OpenAI-compatible

Tout outil ou SDK doté d'un champ URL de base. Les outils de type OpenAI prennent l'URL avec /v1. Les outils de type Anthropic prennent l'URL sans /v1. Même clé, mêmes modèles.

Paramètres
settings
# OpenAI-compatible tools (chat completions or Responses API)
Base URL:  https://unbottled.ai/api/fr-FR/v1
API key:   sk-unb-YOUR_KEY
Model:     glm-5.3

# Anthropic-compatible tools (Messages API)
Base URL:  https://unbottled.ai/api/fr-FR
API key:   sk-unb-YOUR_KEY
Model:     glm-5.3

curl

Vérifiez que la clé fonctionne et listez tous les ids de modèles que vous pouvez appeler. Puis envoyez une première requête.

Vérifier votre clé
terminal
export UNBOTTLED_API_KEY="sk-unb-YOUR_KEY"

curl https://unbottled.ai/api/fr-FR/v1/models \
  -H "Authorization: Bearer $UNBOTTLED_API_KEY"
Première requête
terminal
curl https://unbottled.ai/api/fr-FR/v1/chat/completions \
  -H "Authorization: Bearer $UNBOTTLED_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"glm-5.3","messages":[{"role":"user","content":"Hello"}]}'

Testé avec curl 8.20.0

Remplacez glm-5.3 par n'importe quel id de GET /v1/models, par exemple kimi-k3.1-pro, kimi-k3, uncensored-lm-v1.2. La page des clés API affiche les mêmes blocs, avec votre clé déjà renseignée.

Construisez sur tous les modèles.

Créez une clé, pointez votre SDK ici, livrez.