Pornire rapidă

Fă o primă cerere: ia-ți cheia, trimite un mesaj și citește răspunsul. API-ul vorbește formatele OpenAI și Anthropic, deci SDK-ul pe care îl folosești deja funcționează după ce îi schimbi base URL și cheia.

1. Ia-ți cheia

Fiecare cont are o singură cheie API. Autentifică-te, deschide Keys & usage și copiaz-o. Cheia funcționează pe orice endpoint și cu orice model. Chei și utilizare

2. Îndreaptă clientul spre API

Toate endpoint-urile se află sub un singur base URL. Un SDK OpenAI îl primește cu /v1 la final; un SDK Anthropic îl primește fără, pentru că adaugă singur /v1/messages.

Client	Base URL
SDK-uri OpenAI și clienți compatibili cu OpenAI	`https://api.shannon-ai.com/v1`
SDK-uri Anthropic	`https://api.shannon-ai.com`

Trei endpoint-uri produc text. Ele ajung la aceleași modele; alege-l pe cel al cărui format îl folosește deja codul tău.

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

3. Trimite o primă cerere

Trimite un mesaj user către shannon-3 pe endpoint-ul Chat Completions. Înlocuiește YOUR_API_KEY cu cheia ta.

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

Câmp	Tip	Implicit	Descriere
`model`	`string`		Id-ul modelului care răspunde. Id-urile sunt listate în Models & pricing.
`messages`	`array`		Conversația de până acum: obiecte cu `role` și `content`. Ultimul mesaj `user` este prompt-ul. Obligatoriu.
`max_tokens`	`integer`	`4096`	Bugetul de ieșire al cererii, de la 1 la 65,536. Cererea rezervă această sumă din soldul tău și este taxată pentru ce a folosit efectiv.
`stream`	`boolean`	`false`	`true` trimite răspunsul bucată cu bucată, pe măsură ce este scris.

Corpul cererii este JSON și cere header-ul Content-Type: application/json. Lista completă a câmpurilor se află pe pagina endpoint-ului. Chat Completions

Răspunsul

Un apel fără stream returnează un singur obiect JSON când răspunsul este complet. Textele și numerele de mai jos sunt exemple.

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

Câmp	Tip	Descriere
`id`	`string`	`chatcmpl-` urmat de 32 de caractere hexazecimale.
`object`	`string`	Întotdeauna `chat.completion`.
`created`	`integer`	Momentul răspunsului, în secunde Unix.
`model`	`string`	Id-ul publicat al modelului care a răspuns, și când ai trimis un alias sau o altă scriere.
`choices`	`array`	Întotdeauna o singură intrare, cu `index` 0.
`choices[0].message.role`	`string`	Întotdeauna `assistant`.
`choices[0].message.content`	`string \| null`	Răspunsul. Poate fi `null` când răspunsul conține `tool_calls`.
`choices[0].message.reasoning_content`	`string \| null`	Raționamentul modelului dinaintea răspunsului sau `null` când nu există.
`choices[0].message.tool_calls`	`array`	Prezent doar când modelul apelează unul dintre instrumentele pe care le-ai declarat.
`choices[0].finish_reason`	`string`	`stop` pentru un răspuns, `tool_calls` când modelul apelează un instrument.
`usage.prompt_tokens`	`integer`	Token-urile citite de model pentru acest răspuns. Pe `shannon-2-*` și familia Shannon 3 pot fi mai multe decât textul pe care l-ai trimis.
`usage.completion_tokens`	`integer`	Token-urile scrise de model.
`usage.total_tokens`	`integer`	Totalul. Taxa unui model Shannon se calculează din acest număr.

usage conține numere de token-uri, nu bani. Ce a luat apelul din soldul tău se vede per cerere în Keys & usage; cum se calculează se află la Limite și sold. Limite și sold
Fiecare răspuns, și o eroare, și un stream, are header-ul x-request-id. Dacă cererea ta conține un header x-request-id, valoarea lui revine; altfel valoarea are 12 caractere hexazecimale. Păstrează-o în log-uri: identifică această cerere anume.

Același apel, ca stream

Setează stream la true pentru a citi răspunsul pe măsură ce este scris. Restul cererii rămâne la fel.

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

Fiecare frame al stream-ului este o linie care începe cu data: și conține un obiect JSON. Un frame, tipărit pe mai multe linii:

Un frame

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

Frame-uri, în ordine	delta	finish_reason
Cât timp modelul raționează. Zero sau mai multe frame-uri.	`{"reasoning_content": "…"}`	`null`
Răspunsul, bucată cu bucată. Zero sau mai multe frame-uri.	`{"content": "…"}`	`null`
Ultimul frame JSON. Conține și `usage`; nu trebuie să îl ceri.	`{}`	`"stop"`
Sfârșitul stream-ului: linia `data: [DONE]`.

Răspunsul are statusul 200 și content-type: text/event-stream. Fiecare frame este o linie data: <json> urmată de o linie goală.
O linie : ping sosește la fiecare 15 secunde. Este un comentariu care ține conexiunea deschisă; clienții SSE o sar.
Un eșec după deschiderea stream-ului sosește ca un frame data: {"error": {…}}. Statusul rămâne 200, deci verifică frame-urile.

Streaming

Dacă apelul eșuează

O eroare este un obiect JSON cu un error care conține type și message. Acestea sunt răspunsurile pe care le întâlnește cel mai des un prim apel.

Stare	Tip	Mesaj	Ce înseamnă
`401`	`authentication_error`	`Missing authentication`	Nicio cheie nu a ajuns la API. Trimite `Authorization: Bearer` urmat de cheia ta.
`401`	`authentication_error`	`Invalid API key`	Cheia nu este cheia curentă a unui cont. Copiază-o din nou din Keys & usage.
`400`	`invalid_request_error`	`unknown model: <id>`	`model` nu este un id publicat. Folosește un id din Models & pricing.
`422`	`invalid_request_error`	`Failed to deserialize the JSON body into the target type…`	Un câmp are tip JSON greșit sau lipsește `messages`.
`429`	`rate_limit_error`	`Quota exceeded. Upgrade your plan at shannon-ai.com/plan`	Bugetul de ieșire al cererii nu încape în soldul tău.

Gestionare erori

Unde mergi mai departe

Modele și prețuri — Alege un model: id-uri, ferestre de context și prețuri.
Chat Completions — Fiecare câmp de cerere, câmp de răspuns și eveniment de stream al endpoint-ului apelat.
Streaming — Frame-urile unui stream, liniile keep-alive și erorile din interiorul unui stream.
Apelare funcții — Lasă modelul să îți apeleze funcțiile.
Limite și sold — Ce rezervă și cât costă o cerere și câte cereri poți trimite.
Playground API — Încearcă cereri în browser cu cheia ta.