Schnellstart

Senden Sie eine erste Anfrage: Key besorgen, eine Nachricht senden und die Antwort lesen. Die API spricht die Formate von OpenAI und Anthropic, sodass das SDK, das Sie bereits verwenden, funktioniert, sobald Sie Base-URL und Key ändern.

1. Besorgen Sie Ihren Key

Jedes Konto hat einen API-Key. Melden Sie sich an, öffnen Sie Keys & Nutzung und kopieren Sie ihn. Der Key funktioniert bei jedem Endpunkt und jedem Modell. Keys & Nutzung

2. Richten Sie Ihren Client auf die API

Alle Endpunkte liegen unter einer Base-URL. Ein OpenAI-SDK nimmt sie mit /v1 am Ende; ein Anthropic-SDK nimmt sie ohne, weil es /v1/messages selbst anhängt.

Client	Base-URL
OpenAI-SDKs und OpenAI-kompatible Clients	`https://api.shannon-ai.com/v1`
Anthropic-SDKs	`https://api.shannon-ai.com`

Drei Endpunkte erzeugen Text. Sie erreichen dieselben Modelle; wählen Sie den, dessen Format Ihr Code bereits verwendet.

Endpunkt	Format
`POST /v1/chat/completions`	OpenAI Chat Completions
`POST /v1/messages`	Anthropic Messages
`POST /v1/responses`	OpenAI Responses

3. Senden Sie eine erste Anfrage

Senden Sie eine user-Nachricht an shannon-3 beim Chat-Completions-Endpunkt. Ersetzen Sie YOUR_API_KEY durch Ihren Key.

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

Feld	Typ	Standard	Beschreibung
`model`	`string`		Die ID des Modells, das antwortet. Die IDs sind unter Modelle & Preise aufgeführt.
`messages`	`array`		Die bisherige Konversation: Objekte mit `role` und `content`. Die letzte `user`-Nachricht ist der Prompt. Erforderlich.
`max_tokens`	`integer`	`4096`	Das Output-Budget der Anfrage, von 1 bis 65,536. Die Anfrage reserviert diesen Betrag von Ihrem Guthaben und wird für das berechnet, was sie tatsächlich verbraucht hat.
`stream`	`boolean`	`false`	`true` sendet die Antwort Stück für Stück, während sie geschrieben wird.

Der Request-Body ist JSON und braucht den Header Content-Type: application/json. Die vollständige Liste der Felder steht auf der Seite des Endpunkts. Chat Completions

Die Antwort

Ein Aufruf ohne stream gibt ein JSON-Objekt zurück, wenn die Antwort vollständig ist. Die Texte und Zahlen unten sind Beispiele.

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

Feld	Typ	Beschreibung
`id`	`string`	`chatcmpl-` gefolgt von 32 hexadezimalen Zeichen.
`object`	`string`	Immer `chat.completion`.
`created`	`integer`	Der Zeitpunkt der Antwort in Unix-Sekunden.
`model`	`string`	Die veröffentlichte ID des Modells, das geantwortet hat, auch wenn Sie einen Alias oder eine andere Schreibweise gesendet haben.
`choices`	`array`	Immer ein Eintrag, mit `index` 0.
`choices[0].message.role`	`string`	Immer `assistant`.
`choices[0].message.content`	`string \| null`	Die Antwort. Sie kann `null` sein, wenn die Antwort `tool_calls` enthält.
`choices[0].message.reasoning_content`	`string \| null`	Das Reasoning des Modells vor seiner Antwort oder `null`, wenn es keines gibt.
`choices[0].message.tool_calls`	`array`	Nur vorhanden, wenn das Modell eines der von Ihnen deklarierten Tools aufruft.
`choices[0].finish_reason`	`string`	`stop` für eine Antwort, `tool_calls`, wenn das Modell ein Tool aufruft.
`usage.prompt_tokens`	`integer`	Die Tokens, die das Modell für diese Antwort gelesen hat. Bei `shannon-2-*` und der Shannon-3-Familie kann das mehr sein als der Text, den Sie gesendet haben.
`usage.completion_tokens`	`integer`	Die Tokens, die das Modell geschrieben hat.
`usage.total_tokens`	`integer`	Die Summe. Die Berechnung eines Shannon-Modells wird aus dieser Zahl ermittelt.

usage enthält Token-Anzahlen, kein Geld. Was der Aufruf von Ihrem Guthaben abgezogen hat, wird pro Anfrage unter Keys & Nutzung angezeigt; wie es berechnet wird, steht unter Limits und Guthaben. Limits und Guthaben
Jede Antwort, auch ein Fehler und ein Stream, hat den Header x-request-id. Trägt Ihre Anfrage einen Header x-request-id, kommt dessen Wert zurück; andernfalls besteht der Wert aus 12 hexadezimalen Zeichen. Bewahren Sie ihn in Ihren Logs auf: Er benennt genau diese eine Anfrage.

Derselbe Aufruf als Stream

Setzen Sie stream auf true, um die Antwort zu lesen, während sie geschrieben wird. Alles andere in der Anfrage bleibt gleich.

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

Jeder Frame des Streams ist eine Zeile, die mit data: beginnt und ein JSON-Objekt enthält. Ein Frame, auf mehrere Zeilen verteilt ausgegeben:

Ein Frame

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

Frames, in der Reihenfolge	delta	finish_reason
Während das Modell nachdenkt. Null oder mehr Frames.	`{"reasoning_content": "…"}`	`null`
Die Antwort, Stück für Stück. Null oder mehr Frames.	`{"content": "…"}`	`null`
Der letzte JSON-Frame. Er enthält auch `usage`; Sie müssen es nicht anfordern.	`{}`	`"stop"`
Das Ende des Streams: die Zeile `data: [DONE]`.

Die Antwort hat den Status 200 und content-type: text/event-stream. Jeder Frame ist eine Zeile data: <json>, gefolgt von einer leeren Zeile.
Alle 15 Sekunden trifft eine Zeile : ping ein. Sie ist ein Kommentar, der die Verbindung offen hält; SSE-Clients überspringen sie.
Ein Fehler, nachdem der Stream geöffnet wurde, trifft als Frame data: {"error": {…}} ein. Der Status bleibt 200, prüfen Sie daher die Frames.

Streaming

Wenn der Aufruf fehlschlägt

Ein Fehler ist ein JSON-Objekt mit einem error, das type und message enthält. Dies sind die Antworten, auf die ein erster Aufruf am häufigsten stößt.

Status	Typ	Nachricht	Was es bedeutet
`401`	`authentication_error`	`Missing authentication`	Es ist kein Key bei der API angekommen. Senden Sie `Authorization: Bearer` gefolgt von Ihrem Key.
`401`	`authentication_error`	`Invalid API key`	Der Key ist nicht der aktuelle Key eines Kontos. Kopieren Sie ihn erneut aus Keys & Nutzung.
`400`	`invalid_request_error`	`unknown model: <id>`	`model` ist keine veröffentlichte ID. Verwenden Sie eine ID aus Modelle & Preise.
`422`	`invalid_request_error`	`Failed to deserialize the JSON body into the target type…`	Ein Feld hat den falschen JSON-Typ, oder `messages` fehlt.
`429`	`rate_limit_error`	`Quota exceeded. Upgrade your plan at shannon-ai.com/plan`	Das Output-Budget der Anfrage passt nicht in Ihr Guthaben.

Fehlerbehandlung

Wie es weitergeht

Modelle & Preise — Ein Modell wählen: IDs, Kontextfenster und Preise.
Chat Completions — Jedes Anfragefeld, Antwortfeld und Stream-Event des Endpunkts, den Sie aufgerufen haben.
Streaming — Die Frames eines Streams, Keep-alive-Zeilen und Fehler innerhalb eines Streams.
Funktionsaufrufe — Das Modell Ihre Funktionen aufrufen lassen.
Limits und Guthaben — Was eine Anfrage reserviert und kostet und wie viele Anfragen Sie senden dürfen.
API‑Playground — Anfragen im Browser mit Ihrem Key ausprobieren.