Snabbstart

Gör en första begäran: hämta din nyckel, skicka ett meddelande och läs svaret. API:et talar OpenAI- och Anthropic-formaten, så den SDK du redan använder fungerar när du har ändrat dess bas-URL och nyckel.

1. Hämta din nyckel

Varje konto har en API-nyckel. Logga in, öppna Nycklar och användning och kopiera den. Nyckeln fungerar på varje endpoint och varje modell. Nycklar och användning

2. Peka din klient mot API:et

Alla endpoints ligger under en bas-URL. En OpenAI-SDK tar den med /v1 i slutet; en Anthropic-SDK tar den utan, eftersom den själv lägger till /v1/messages.

Klient	Bas-URL
OpenAI-SDK:er och OpenAI-kompatibla klienter	`https://api.shannon-ai.com/v1`
Anthropic-SDK:er	`https://api.shannon-ai.com`

Tre endpoints producerar text. De når samma modeller; välj den vars format din kod redan använder.

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

3. Skicka en första begäran

Skicka ett user-meddelande till shannon-3 på endpointen Chat Completions. Ersätt YOUR_API_KEY med din nyckel.

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

Fält	Typ	Standard	Beskrivning
`model`	`string`		Id:t för modellen som svarar. Id:na listas på Modeller och priser.
`messages`	`array`		Konversationen hittills: objekt med `role` och `content`. Det sista `user`-meddelandet är prompten. Obligatoriskt.
`max_tokens`	`integer`	`4096`	Begärans outputbudget, från 1 till 65,536. Begäran reserverar det beloppet från din balans och debiteras för det den faktiskt använde.
`stream`	`boolean`	`false`	`true` skickar svaret bit för bit medan det skrivs.

Begäranbodyn är JSON och kräver headern Content-Type: application/json. Den fullständiga listan över fält finns på endpointsidan. Chat Completions

Svaret

Ett anrop utan stream returnerar ett JSON-objekt när svaret är komplett. Texterna och talen nedan är exempel.

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

Fält	Typ	Beskrivning
`id`	`string`	`chatcmpl-` följt av 32 hexadecimala tecken.
`object`	`string`	Alltid `chat.completion`.
`created`	`integer`	Svarets tidpunkt i Unix-sekunder.
`model`	`string`	Det publicerade id:t för modellen som svarade, även när du skickade ett alias eller en annan stavning.
`choices`	`array`	Alltid en post, med `index` 0.
`choices[0].message.role`	`string`	Alltid `assistant`.
`choices[0].message.content`	`string \| null`	Svaret. Det kan vara `null` när svaret innehåller `tool_calls`.
`choices[0].message.reasoning_content`	`string \| null`	Modellens resonemang före svaret, eller `null` när det inte finns något.
`choices[0].message.tool_calls`	`array`	Finns bara när modellen anropar ett av de verktyg som du deklarerade.
`choices[0].finish_reason`	`string`	`stop` för ett svar, `tool_calls` när modellen anropar ett verktyg.
`usage.prompt_tokens`	`integer`	De tokens som modellen läste för det här svaret. På `shannon-2-*` och Shannon 3-familjen kan detta vara fler än den text du skickade.
`usage.completion_tokens`	`integer`	De tokens som modellen skrev.
`usage.total_tokens`	`integer`	Totalen. Debiteringen för en Shannon-modell beräknas från det här talet.

usage innehåller tokenantal, inte pengar. Vad anropet tog från din balans visas per begäran på Nycklar och användning; hur det beräknas står på Gränser och balans. Gränser och balans
Varje svar, även ett fel och en ström, har headern x-request-id. Om din begäran har en x-request-id-header kommer dess värde tillbaka; annars är värdet 12 hexadecimala tecken. Spara det i dina loggar: det identifierar just den här begäran.

Samma anrop som en ström

Sätt stream till true för att läsa svaret medan det skrivs. Allt annat i begäran är oförändrat.

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

Varje frame i strömmen är en rad som börjar med data: och innehåller ett JSON-objekt. En frame, utskriven på flera rader:

En frame

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

Frames, i ordning	delta	finish_reason
Medan modellen resonerar. Noll eller fler frames.	`{"reasoning_content": "…"}`	`null`
Svaret, bit för bit. Noll eller fler frames.	`{"content": "…"}`	`null`
Den sista JSON-framen. Den bär också `usage`; du behöver inte be om den.	`{}`	`"stop"`
Strömmens slut: raden `data: [DONE]`.

Svaret har status 200 och content-type: text/event-stream. Varje frame är en rad data: <json> följd av en tom rad.
En rad : ping kommer var 15:e sekund. Det är en kommentar som håller anslutningen öppen; SSE-klienter hoppar över den.
Ett fel efter att strömmen har öppnats kommer som en frame data: {"error": {…}}. Statusen förblir 200, så kontrollera framen.

Streaming

Om anropet misslyckas

Ett fel är ett JSON-objekt med ett error som innehåller type och message. Det här är de svar som ett första anrop oftast möter.

Status	Typ	Meddelande	Vad det betyder
`401`	`authentication_error`	`Missing authentication`	Ingen nyckel nådde API:et. Skicka `Authorization: Bearer` följt av din nyckel.
`401`	`authentication_error`	`Invalid API key`	Nyckeln är inte ett kontos aktuella nyckel. Kopiera den igen från Nycklar och användning.
`400`	`invalid_request_error`	`unknown model: <id>`	`model` är inte ett publicerat id. Använd ett id från Modeller och priser.
`422`	`invalid_request_error`	`Failed to deserialize the JSON body into the target type…`	Ett fält har fel JSON-typ, eller `messages` saknas.
`429`	`rate_limit_error`	`Quota exceeded. Upgrade your plan at shannon-ai.com/plan`	Begärans outputbudget ryms inte i din balans.

Felhantering

Vart du går härnäst

Modeller och priser — Välj en modell: id:n, kontextfönster och priser.
Chat Completions — Varje begäranfält, svarsfält och strömhändelse för den endpoint du anropade.
Streaming — En strömmens frames, keep-alive-rader och fel inne i en ström.
Funktionsanrop — Låt modellen anropa dina funktioner.
Gränser och balans — Vad en begäran reserverar och kostar, och hur många begäranden du får skicka.
API‑Playground — Prova begäranden i webbläsaren med din nyckel.