Hurtigstart

Gjør en første forespørsel: hent nøkkelen din, send én melding og les svaret. API-et snakker OpenAI- og Anthropic-formatene, så SDK-en du allerede bruker, fungerer etter at du har byttet base-URL og nøkkel.

1. Hent nøkkelen din

Hver konto har én API-nøkkel. Logg inn, åpne Keys & usage og kopier den. Nøkkelen fungerer på alle endepunkter og alle modeller. Nøkler og bruk

2. Pek klienten din mot API-et

Alle endepunkter ligger under én base-URL. En OpenAI-SDK tar den med /v1 på slutten; en Anthropic-SDK tar den uten, fordi den legger til /v1/messages selv.

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 endepunkter produserer tekst. De når de samme modellene; velg det som har formatet koden din allerede bruker.

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

3. Send en første forespørsel

Send én user-melding til shannon-3 på endepunktet Chat Completions. Erstatt YOUR_API_KEY med nøkkelen din.

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-en til modellen som svarer. Id-ene er listet på Models & pricing.
`messages`	`array`		Samtalen så langt: objekter med `role` og `content`. Den siste `user`-meldingen er prompten. Påkrevd.
`max_tokens`	`integer`	`4096`	Utdatabudsjettet til forespørselen, fra 1 til 65,536. Forespørselen reserverer dette beløpet fra saldoen din og belastes for det den faktisk brukte.
`stream`	`boolean`	`false`	`true` sender svaret stykke for stykke mens det skrives.

Forespørselskroppen er JSON og trenger headeren Content-Type: application/json. Den fulle listen over felt står på endepunktsiden. Chat Completions

Svaret

Et kall uten stream returnerer ett JSON-objekt når svaret er fullført. Tekstene 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-` etterfulgt av 32 heksadesimale tegn.
`object`	`string`	Alltid `chat.completion`.
`created`	`integer`	Tidspunktet for svaret i Unix-sekunder.
`model`	`string`	Den publiserte id-en til modellen som svarte, også når du sendte et alias eller en annen skrivemåte.
`choices`	`array`	Alltid én oppføring, med `index` 0.
`choices[0].message.role`	`string`	Alltid `assistant`.
`choices[0].message.content`	`string \| null`	Svaret. Det kan være `null` når svaret har `tool_calls`.
`choices[0].message.reasoning_content`	`string \| null`	Modellens resonnering før svaret, eller `null` når det ikke finnes noen.
`choices[0].message.tool_calls`	`array`	Finnes bare når modellen kaller et av verktøyene du deklarerte.
`choices[0].finish_reason`	`string`	`stop` for et svar, `tool_calls` når modellen kaller et verktøy.
`usage.prompt_tokens`	`integer`	Tokens modellen leste for dette svaret. På `shannon-2-*` og Shannon 3-familien kan dette være mer enn teksten du sendte.
`usage.completion_tokens`	`integer`	Tokens modellen skrev.
`usage.total_tokens`	`integer`	Totalen. Belastningen for en Shannon-modell beregnes fra dette tallet.

usage inneholder tokenantall, ikke penger. Hva kallet tok fra saldoen din, vises per forespørsel på Keys & usage; hvordan det beregnes, står under Grenser og saldo. Grenser og saldo
Hvert svar, også en feil og en strøm, har headeren x-request-id. Hvis forespørselen din har en x-request-id-header, kommer verdien tilbake; ellers er verdien 12 heksadesimale tegn. Ta vare på den i loggene dine: den identifiserer akkurat denne forespørselen.

Det samme kallet som en strøm

Sett stream til true for å lese svaret mens det skrives. Alt annet i forespørselen forblir 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 strømmen er én linje som starter med data: og inneholder et JSON-objekt. Én ramme, skrevet ut 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 rekkefølge	delta	finish_reason
Mens modellen resonnerer. Null eller flere rammer.	`{"reasoning_content": "…"}`	`null`
Svaret, stykke for stykke. Null eller flere rammer.	`{"content": "…"}`	`null`
Den siste JSON-rammen. Den har også `usage`; du trenger ikke be om det.	`{}`	`"stop"`
Slutten på strømmen: linjen `data: [DONE]`.

Svaret har status 200 og content-type: text/event-stream. Hver ramme er en linje data: <json> etterfulgt av en tom linje.
En linje : ping kommer hvert 15. sekund. Det er en kommentar som holder forbindelsen åpen; SSE-klienter hopper over den.
En feil etter at strømmen er åpnet, kommer som en ramme data: {"error": {…}}. Statusen forblir 200, så sjekk rammene.

Strømming

Hvis kallet feiler

En feil er et JSON-objekt med en error som inneholder type og message. Dette er svarene et første kall oftest møter.

Status	Type	Melding	Hva det betyr
`401`	`authentication_error`	`Missing authentication`	Ingen nøkkel nådde API-et. Send `Authorization: Bearer` etterfulgt av nøkkelen din.
`401`	`authentication_error`	`Invalid API key`	Nøkkelen er ikke den gjeldende nøkkelen til en konto. Kopier den på nytt fra Keys & usage.
`400`	`invalid_request_error`	`unknown model: <id>`	`model` er ikke en publisert id. Bruk en id fra Models & pricing.
`422`	`invalid_request_error`	`Failed to deserialize the JSON body into the target type…`	Et felt har feil JSON-type, eller `messages` mangler.
`429`	`rate_limit_error`	`Quota exceeded. Upgrade your plan at shannon-ai.com/plan`	Utdatabudsjettet til forespørselen får ikke plass i saldoen din.

Feilhåndtering

Hvor du går videre

Modeller og priser — Velg en modell: id-er, kontekstvinduer og priser.
Chat Completions — Hvert forespørselsfelt, svarfelt og hver strømhendelse for endepunktet du kalte.
Strømming — Rammene i en strøm, keep-alive-linjer og feil inne i en strøm.
Funksjonskall — La modellen kalle funksjonene dine.
Grenser og saldo — Hva en forespørsel reserverer og koster, og hvor mange forespørsler du kan sende.
API‑lekeplass — Prøv forespørsler i nettleseren med nøkkelen din.