Démarrage rapide

Faites une première requête : obtenez votre clé, envoyez un message et lisez la réponse. L'API parle les formats OpenAI et Anthropic, donc le SDK que vous utilisez déjà fonctionne une fois son URL de base et sa clé changées.

1. Obtenez votre clé

Chaque compte a une clé API. Connectez-vous, ouvrez Clés et utilisation et copiez-la. La clé fonctionne sur tous les points de terminaison et avec tous les modèles. Clés et utilisation

2. Pointez votre client vers l'API

Tous les points de terminaison se trouvent sous une seule URL de base. Un SDK OpenAI la prend avec /v1 à la fin ; un SDK Anthropic la prend sans, car il ajoute lui-même /v1/messages.

Client	URL de base
SDK OpenAI et clients compatibles OpenAI	`https://api.shannon-ai.com/v1`
SDK Anthropic	`https://api.shannon-ai.com`

Trois points de terminaison produisent du texte. Ils atteignent les mêmes modèles ; choisissez celui dont votre code utilise déjà le format.

Point de terminaison	Format
`POST /v1/chat/completions`	OpenAI Chat Completions
`POST /v1/messages`	Anthropic Messages
`POST /v1/responses`	OpenAI Responses

3. Envoyez une première requête

Envoyez un message user à shannon-3 sur le point de terminaison Chat Completions. Remplacez YOUR_API_KEY par votre clé.

POST https://api.shannon-ai.com/v1/chat/completions

from openai import OpenAI

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

response = client.chat.completions.create(
    model="shannon-3",
    messages=[
        {"role": "user", "content": "Hello, Shannon!"}
    ],
    max_tokens=1024
)

print(response.choices[0].message.content)

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'YOUR_API_KEY',
  baseURL: 'https://api.shannon-ai.com/v1'
});

const response = await client.chat.completions.create({
  model: 'shannon-3',
  messages: [
    { role: 'user', content: 'Hello, Shannon!' }
  ],
  max_tokens: 1024
});

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

package main

import (
    "context"
    "fmt"
    openai "github.com/sashabaranov/go-openai"
)

func main() {
    config := openai.DefaultConfig("YOUR_API_KEY")
    config.BaseURL = "https://api.shannon-ai.com/v1"
    client := openai.NewClientWithConfig(config)

    resp, err := client.CreateChatCompletion(
        context.Background(),
        openai.ChatCompletionRequest{
            Model: "shannon-3",
            Messages: []openai.ChatCompletionMessage{
                {Role: "user", Content: "Hello, Shannon!"},
            },
            MaxTokens: 1024,
        },
    )
    if err != nil {
        panic(err)
    }
    fmt.Println(resp.Choices[0].Message.Content)
}

curl -X POST "https://api.shannon-ai.com/v1/chat/completions" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "shannon-3",
    "messages": [
      {"role": "user", "content": "Hello, Shannon!"}
    ],
    "max_tokens": 1024
  }'

Champ	Type	Par défaut	Description
`model`	`string`		L'id du modèle qui répond. Les ids sont listés dans Modèles et tarifs.
`messages`	`array`		La conversation jusqu'ici : des objets avec `role` et `content`. Le dernier message `user` est le prompt. Obligatoire.
`max_tokens`	`integer`	`4096`	Le budget de sortie de la requête, de 1 à 65,536. La requête réserve ce montant sur votre solde et est facturée pour ce qu'elle a réellement utilisé.
`stream`	`boolean`	`false`	`true` envoie la réponse morceau par morceau pendant qu'elle s'écrit.

Le corps de la requête est du JSON et demande l'en-tête Content-Type: application/json. La liste complète des champs est sur la page du point de terminaison. Chat Completions

La réponse

Un appel sans stream renvoie un seul objet JSON quand la réponse est complète. Les textes et les nombres ci-dessous sont des exemples.

200 JSON

{
  "id": "chatcmpl-9b2f6c1e4a7d4f0f8a3c5d2e1b6a7c90",
  "object": "chat.completion",
  "created": 1791590400,
  "model": "shannon-3",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Hello! What would you like to work on?",
        "reasoning_content": "A greeting. A short, friendly reply fits."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 1386,
    "completion_tokens": 74,
    "total_tokens": 1460
  }
}

Champ	Type	Description
`id`	`string`	`chatcmpl-` suivi de 32 caractères hexadécimaux.
`object`	`string`	Toujours `chat.completion`.
`created`	`integer`	L'heure de la réponse en secondes Unix.
`model`	`string`	L'id publié du modèle qui a répondu, y compris quand vous avez envoyé un alias ou une autre écriture.
`choices`	`array`	Toujours une seule entrée, avec `index` 0.
`choices[0].message.role`	`string`	Toujours `assistant`.
`choices[0].message.content`	`string \| null`	La réponse. Elle peut être `null` quand la réponse porte des `tool_calls`.
`choices[0].message.reasoning_content`	`string \| null`	Le raisonnement du modèle avant sa réponse, ou `null` s'il n'y en a pas.
`choices[0].message.tool_calls`	`array`	Présent seulement quand le modèle appelle l'un des outils que vous avez déclarés.
`choices[0].finish_reason`	`string`	`stop` pour une réponse, `tool_calls` quand le modèle appelle un outil.
`usage.prompt_tokens`	`integer`	Les tokens que le modèle a lus pour cette réponse. Sur `shannon-2-*` et la famille Shannon 3, cela peut dépasser le texte que vous avez envoyé.
`usage.completion_tokens`	`integer`	Les tokens écrits par le modèle.
`usage.total_tokens`	`integer`	Le total. Le coût d'un modèle Shannon est calculé à partir de ce nombre.

usage contient des nombres de tokens, pas de l'argent. Ce que l'appel a prélevé sur votre solde s'affiche par requête dans Clés et utilisation ; le calcul est expliqué dans Limites et solde. Limites et solde
Chaque réponse, y compris une erreur et un flux, a l'en-tête x-request-id. Si votre requête porte un en-tête x-request-id, sa valeur est renvoyée ; sinon la valeur est composée de 12 caractères hexadécimaux. Gardez-la dans vos logs : elle désigne cette requête précise.

Le même appel en flux

Mettez stream à true pour lire la réponse pendant qu'elle s'écrit. Tout le reste de la requête reste identique.

from openai import OpenAI

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

stream = client.chat.completions.create(
    model="shannon-3",
    messages=[
        {"role": "user", "content": "Hello, Shannon!"}
    ],
    max_tokens=1024,
    stream=True
)

for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'YOUR_API_KEY',
  baseURL: 'https://api.shannon-ai.com/v1'
});

const stream = await client.chat.completions.create({
  model: 'shannon-3',
  messages: [
    { role: 'user', content: 'Hello, Shannon!' }
  ],
  max_tokens: 1024,
  stream: true
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? '');
}

curl -N -X POST "https://api.shannon-ai.com/v1/chat/completions" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "shannon-3",
    "messages": [
      {"role": "user", "content": "Hello, Shannon!"}
    ],
    "max_tokens": 1024,
    "stream": true
  }'

Chaque trame du flux est une ligne qui commence par data: et contient un objet JSON. Une trame, affichée sur plusieurs lignes :

Une trame

{
  "id": "chatcmpl-9b2f6c1e4a7d4f0f8a3c5d2e1b6a7c90",
  "object": "chat.completion.chunk",
  "created": 1791590400,
  "model": "shannon-3",
  "choices": [
    {
      "index": 0,
      "delta": {
        "content": "Hello! "
      },
      "finish_reason": null
    }
  ]
}

Trames, dans l'ordre	delta	finish_reason
Pendant que le modèle raisonne. Zéro trame ou plus.	`{"reasoning_content": "…"}`	`null`
La réponse, morceau par morceau. Zéro trame ou plus.	`{"content": "…"}`	`null`
La dernière trame JSON. Elle porte aussi `usage` ; vous n'avez pas besoin de le demander.	`{}`	`"stop"`
La fin du flux : la ligne `data: [DONE]`.

La réponse a le statut 200 et content-type: text/event-stream. Chaque trame est une ligne data: <json> suivie d'une ligne vide.
Une ligne : ping arrive toutes les 15 secondes. C'est un commentaire qui garde la connexion ouverte ; les clients SSE l'ignorent.
Un échec après l'ouverture du flux arrive sous la forme d'une trame data: {"error": {…}}. Le statut reste 200, donc vérifiez les trames.

Diffusion en continu

Si l'appel échoue

Une erreur est un objet JSON avec un champ error qui contient type et message. Voici les réponses que rencontre le plus souvent un premier appel.

Statut	Type	Message	Ce que cela signifie
`401`	`authentication_error`	`Missing authentication`	Aucune clé n'est parvenue à l'API. Envoyez `Authorization: Bearer` suivi de votre clé.
`401`	`authentication_error`	`Invalid API key`	La clé n'est pas la clé actuelle d'un compte. Copiez-la de nouveau depuis Clés et utilisation.
`400`	`invalid_request_error`	`unknown model: <id>`	`model` n'est pas un id publié. Utilisez un id de Modèles et tarifs.
`422`	`invalid_request_error`	`Failed to deserialize the JSON body into the target type…`	Un champ a un type JSON incorrect, ou `messages` est absent.
`429`	`rate_limit_error`	`Quota exceeded. Upgrade your plan at shannon-ai.com/plan`	Le budget de sortie de la requête ne tient pas dans votre solde.

Gestion des erreurs

Pour continuer

Modèles et tarifs — Choisir un modèle : ids, fenêtres de contexte et prix.
Chat Completions — Chaque champ de requête, champ de réponse et événement de flux du point de terminaison que vous avez appelé.
Diffusion en continu — Les trames d'un flux, les lignes keep-alive et les erreurs dans un flux.
Appel de fonction — Laisser le modèle appeler vos fonctions.
Limites et solde — Ce qu'une requête réserve et coûte, et combien de requêtes vous pouvez envoyer.
Terrain de jeu API — Essayer des requêtes dans le navigateur avec votre clé.