Hurtig start

Send en første anmodning: hent din nøgle, send én besked, og læs svaret. API'et taler OpenAI- og Anthropic-formaterne, så det SDK, du allerede bruger, virker, efter du har ændret dets base-URL og nøgle.

1. Hent din nøgle

Hver konto har én API-nøgle. Log ind, åbn Nøgler og forbrug, og kopiér den. Nøglen virker på alle endpoints og alle modeller. Nøgler og forbrug

2. Peg din klient på API'et

Alle endpoints ligger under én base-URL. Et OpenAI-SDK tager den med /v1 til sidst; et Anthropic-SDK tager den uden, fordi det selv tilføjer /v1/messages.

Klient	Base-URL
OpenAI-SDK'er og OpenAI-kompatible klienter	`https://api.shannon-ai.com/v1`
Anthropic-SDK'er	`https://api.shannon-ai.com`

Tre endpoints producerer tekst. De når de samme modeller; vælg det, hvis format din kode allerede bruger.

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

3. Send en første anmodning

Send én user-besked til shannon-3 på Chat Completions-endpointet. Erstat YOUR_API_KEY med din nøgle.

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

Felt	Type	Standard	Beskrivelse
`model`	`string`		Id'et på den model, der svarer. Id'erne står under Modeller og priser.
`messages`	`array`		Samtalen indtil nu: objekter med `role` og `content`. Den sidste `user`-besked er prompten. Påkrævet.
`max_tokens`	`integer`	`4096`	Anmodningens outputbudget, fra 1 til 65,536. Anmodningen reserverer dette beløb fra din saldo og afregnes for det, den reelt brugte.
`stream`	`boolean`	`false`	`true` sender svaret stykke for stykke, mens det skrives.

Anmodningens body er JSON og kræver headeren Content-Type: application/json. Den fulde liste over felter står på endpointets side. Chat Completions

Svaret

Et kald uden stream returnerer ét JSON-objekt, når svaret er færdigt. Teksterne og tallene nedenfor er eksempler.

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

Felt	Type	Beskrivelse
`id`	`string`	`chatcmpl-` efterfulgt af 32 hexadecimale tegn.
`object`	`string`	Altid `chat.completion`.
`created`	`integer`	Svarets tidspunkt i Unix-sekunder.
`model`	`string`	Det offentliggjorte id på den model, der svarede, også når du sendte et alias eller en anden stavemåde.
`choices`	`array`	Altid én post, med `index` 0.
`choices[0].message.role`	`string`	Altid `assistant`.
`choices[0].message.content`	`string \| null`	Svaret. Det kan være `null`, når svaret indeholder `tool_calls`.
`choices[0].message.reasoning_content`	`string \| null`	Modellens ræsonnement før svaret, eller `null`, når der ikke er noget.
`choices[0].message.tool_calls`	`array`	Findes kun, når modellen kalder et af de værktøjer, du erklærede.
`choices[0].finish_reason`	`string`	`stop` for et svar, `tool_calls` når modellen kalder et værktøj.
`usage.prompt_tokens`	`integer`	De tokens, modellen læste til dette svar. På `shannon-2-*` og Shannon 3-familien kan det være mere end den tekst, du sendte.
`usage.completion_tokens`	`integer`	De tokens, modellen skrev.
`usage.total_tokens`	`integer`	Summen. Afregningen for en Shannon-model beregnes ud fra dette tal.

usage indeholder token-tællinger, ikke penge. Hvad kaldet tog fra din saldo, vises per anmodning under Nøgler og forbrug; hvordan det beregnes, står under Grænser og saldo. Grænser og saldo
Hvert svar, også en fejl og en stream, har headeren x-request-id. Hvis din anmodning har en x-request-id-header, kommer dens værdi tilbage; ellers er værdien 12 hexadecimale tegn. Gem den i dine logs: den angiver netop denne ene anmodning.

Det samme kald som en stream

Sæt stream til true for at læse svaret, mens det skrives. Alt andet i anmodningen forbliver det samme.

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

Hver ramme i streamen er én linje, der starter med data: og indeholder et JSON-objekt. Én ramme, udskrevet på flere linjer:

Én ramme

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

Rammer, i rækkefølge	delta	finish_reason
Mens modellen ræsonnerer. Nul eller flere rammer.	`{"reasoning_content": "…"}`	`null`
Svaret, stykke for stykke. Nul eller flere rammer.	`{"content": "…"}`	`null`
Den sidste JSON-ramme. Den indeholder også `usage`; du behøver ikke bede om det.	`{}`	`"stop"`
Streamens slutning: linjen `data: [DONE]`.

Svaret har status 200 og content-type: text/event-stream. Hver ramme er en linje data: <json> efterfulgt af en tom linje.
En linje : ping ankommer hvert 15. sekund. Det er en kommentar, der holder forbindelsen åben; SSE-klienter springer den over.
En fejl, efter at streamen er åbnet, ankommer som en ramme data: {"error": {…}}. Statussen forbliver 200, så kontrollér rammerne.

Streaming

Hvis kaldet fejler

En fejl er et JSON-objekt med en error, der indeholder type og message. Det er de svar, et første kald oftest møder.

Status	Type	Besked	Hvad det betyder
`401`	`authentication_error`	`Missing authentication`	Ingen nøgle nåede frem til API'et. Send `Authorization: Bearer` efterfulgt af din nøgle.
`401`	`authentication_error`	`Invalid API key`	Nøglen er ikke en kontos nuværende nøgle. Kopiér den igen fra Nøgler og forbrug.
`400`	`invalid_request_error`	`unknown model: <id>`	`model` er ikke et offentliggjort id. Brug et id fra Modeller og priser.
`422`	`invalid_request_error`	`Failed to deserialize the JSON body into the target type…`	Et felt har den forkerte JSON-type, eller `messages` mangler.
`429`	`rate_limit_error`	`Quota exceeded. Upgrade your plan at shannon-ai.com/plan`	Anmodningens outputbudget kan ikke rummes i din saldo.

Fejlhåndtering

Hvor du kan gå videre

Modeller og priser — Vælg en model: id'er, kontekstvinduer og priser.
Chat Completions — Hvert anmodningsfelt, svarfelt og hver stream-hændelse i det endpoint, du kaldte.
Streaming — Rammerne i en stream, keep-alive-linjer og fejl inde i en stream.
Funktionskald — Lad modellen kalde dine funktioner.
Grænser og saldo — Hvad en anmodning reserverer og koster, og hvor mange anmodninger du må sende.
API‑Playground — Prøv anmodninger i browseren med din nøgle.