Snelle start

Doe een eerste aanvraag: haal je sleutel op, verstuur één bericht en lees het antwoord. De API spreekt de formaten van OpenAI en Anthropic, dus de SDK die je al gebruikt werkt nadat je de basis-URL en de sleutel hebt gewijzigd.

1. Haal je sleutel op

Elk account heeft één API-sleutel. Log in, open Keys & usage en kopieer hem. De sleutel werkt op elk endpoint en elk model. Sleutels en gebruik

2. Richt je client op de API

Alle endpoints staan onder één basis-URL. Een OpenAI-SDK neemt hem met /v1 aan het eind; een Anthropic-SDK neemt hem zonder, omdat die /v1/messages zelf toevoegt.

Client	Basis-URL
OpenAI-SDK's en OpenAI-compatibele clients	`https://api.shannon-ai.com/v1`
Anthropic-SDK's	`https://api.shannon-ai.com`

Drie endpoints produceren tekst. Ze bereiken dezelfde modellen; kies het endpoint waarvan je code het formaat al gebruikt.

Endpoint	Formaat
`POST /v1/chat/completions`	OpenAI Chat Completions
`POST /v1/messages`	Anthropic Messages
`POST /v1/responses`	OpenAI Responses

3. Verstuur een eerste aanvraag

Verstuur één user-bericht naar shannon-3 op het Chat Completions-endpoint. Vervang YOUR_API_KEY door je sleutel.

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
  }'

Veld	Type	Standaard	Beschrijving
`model`	`string`		De id van het model dat antwoordt. De id's staan vermeld op Models & pricing.
`messages`	`array`		Het gesprek tot nu toe: objecten met `role` en `content`. Het laatste `user`-bericht is de prompt. Vereist.
`max_tokens`	`integer`	`4096`	Het outputbudget van de aanvraag, van 1 tot 65,536. De aanvraag reserveert dit bedrag van je saldo en wordt in rekening gebracht voor wat ze echt heeft gebruikt.
`stream`	`boolean`	`false`	`true` verstuurt het antwoord stukje bij beetje terwijl het wordt geschreven.

De aanvraagbody is JSON en heeft de header Content-Type: application/json nodig. De volledige lijst van velden staat op de endpointpagina. Chat Completions

Het antwoord

Een call zonder stream geeft één JSON-object terug zodra het antwoord compleet is. De teksten en getallen hieronder zijn voorbeelden.

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
  }
}

Veld	Type	Beschrijving
`id`	`string`	`chatcmpl-` gevolgd door 32 hexadecimale tekens.
`object`	`string`	Altijd `chat.completion`.
`created`	`integer`	Het tijdstip van het antwoord in Unix-seconden.
`model`	`string`	De gepubliceerde id van het model dat heeft geantwoord, ook als je een alias of een andere schrijfwijze hebt gestuurd.
`choices`	`array`	Altijd één item, met `index` 0.
`choices[0].message.role`	`string`	Altijd `assistant`.
`choices[0].message.content`	`string \| null`	Het antwoord. Het kan `null` zijn als het antwoord `tool_calls` bevat.
`choices[0].message.reasoning_content`	`string \| null`	De redenering van het model vóór zijn antwoord, of `null` als die er niet is.
`choices[0].message.tool_calls`	`array`	Alleen aanwezig als het model een van de tools aanroept die je hebt gedeclareerd.
`choices[0].finish_reason`	`string`	`stop` voor een antwoord, `tool_calls` als het model een tool aanroept.
`usage.prompt_tokens`	`integer`	De tokens die het model voor dit antwoord heeft gelezen. Bij `shannon-2-*` en de Shannon 3-familie kan dit meer zijn dan de tekst die je hebt gestuurd.
`usage.completion_tokens`	`integer`	De tokens die het model heeft geschreven.
`usage.total_tokens`	`integer`	Het totaal. De kosten van een Shannon-model worden uit dit getal berekend.

usage bevat tokenaantallen, geen geld. Wat de call van je saldo heeft afgenomen, zie je per aanvraag op Keys & usage; hoe het wordt berekend, staat op Limieten en saldo. Limieten en saldo
Elk antwoord, ook een fout en een stream, heeft de header x-request-id. Als je aanvraag een x-request-id-header bevat, komt de waarde ervan terug; anders bestaat de waarde uit 12 hexadecimale tekens. Bewaar hem in je logs: hij benoemt precies deze ene aanvraag.

Dezelfde call als stream

Zet stream op true om het antwoord te lezen terwijl het wordt geschreven. Al het andere in de aanvraag blijft hetzelfde.

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
  }'

Elk frame van de stream is één regel die met data: begint en een JSON-object bevat. Eén frame, op meerdere regels afgedrukt:

Eén frame

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

Frames, in volgorde	delta	finish_reason
Terwijl het model redeneert. Nul of meer frames.	`{"reasoning_content": "…"}`	`null`
Het antwoord, stukje bij beetje. Nul of meer frames.	`{"content": "…"}`	`null`
Het laatste JSON-frame. Het bevat ook `usage`; je hoeft er niet om te vragen.	`{}`	`"stop"`
Het einde van de stream: de regel `data: [DONE]`.

Het antwoord heeft status 200 en content-type: text/event-stream. Elk frame is een regel data: <json> gevolgd door een lege regel.
Elke 15 seconden komt er een regel : ping binnen. Het is een opmerking die de verbinding open houdt; SSE-clients slaan hem over.
Een fout nadat de stream is geopend, komt binnen als een frame data: {"error": {…}}. De status blijft 200, dus controleer de frames.

Streaming

Als de call mislukt

Een fout is een JSON-object met een error die type en message bevat. Dit zijn de antwoorden die een eerste call het vaakst tegenkomt.

Status	Type	Melding	Wat het betekent
`401`	`authentication_error`	`Missing authentication`	Er is geen sleutel bij de API aangekomen. Stuur `Authorization: Bearer` gevolgd door je sleutel.
`401`	`authentication_error`	`Invalid API key`	De sleutel is niet de huidige sleutel van een account. Kopieer hem opnieuw uit Keys & usage.
`400`	`invalid_request_error`	`unknown model: <id>`	`model` is geen gepubliceerde id. Gebruik een id uit Models & pricing.
`422`	`invalid_request_error`	`Failed to deserialize the JSON body into the target type…`	Een veld heeft het verkeerde JSON-type, of `messages` ontbreekt.
`429`	`rate_limit_error`	`Quota exceeded. Upgrade your plan at shannon-ai.com/plan`	Het outputbudget van de aanvraag past niet in je saldo.

Foutafhandeling

Waar je daarna heen kunt

Modellen en prijzen — Kies een model: id's, contextvensters en prijzen.
Chat Completions — Elk aanvraagveld, antwoordveld en elke streamgebeurtenis van het endpoint dat je hebt aangeroepen.
Streaming — De frames van een stream, keep-alive-regels en fouten binnen een stream.
Function calling — Laat het model je functies aanroepen.
Limieten en saldo — Wat een aanvraag reserveert en kost, en hoeveel aanvragen je mag versturen.
API‑Playground — Probeer aanvragen in de browser met je sleutel.