Início rápido

Faça uma primeira requisição: pegue sua chave, envie uma mensagem e leia a resposta. A API fala os formatos da OpenAI e da Anthropic, então o SDK que você já usa funciona depois que você troca a URL base e a chave.

1. Pegue a sua chave

Cada conta tem uma chave de API. Faça login, abra Chaves e uso e copie-a. A chave funciona em todos os endpoints e em todos os modelos. Chaves e uso

2. Aponte o seu cliente para a API

Todos os endpoints ficam sob uma única URL base. Um SDK da OpenAI a recebe com /v1 no final; um SDK da Anthropic a recebe sem, porque ele mesmo acrescenta /v1/messages.

Cliente	URL base
SDKs da OpenAI e clientes compatíveis com a OpenAI	`https://api.shannon-ai.com/v1`
SDKs da Anthropic	`https://api.shannon-ai.com`

Três endpoints produzem texto. Eles alcançam os mesmos modelos; escolha aquele cujo formato o seu código já usa.

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

3. Envie uma primeira requisição

Envie uma mensagem user para shannon-3 no endpoint Chat Completions. Substitua YOUR_API_KEY pela sua chave.

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

Campo	Tipo	Padrão	Descrição
`model`	`string`		O id do modelo que responde. Os ids estão listados em Modelos e preços.
`messages`	`array`		A conversa até agora: objetos com `role` e `content`. A última mensagem `user` é o prompt. Obrigatório.
`max_tokens`	`integer`	`4096`	O orçamento de saída da requisição, de 1 a 65,536. A requisição reserva essa quantidade do seu saldo e é cobrada pelo que realmente usou.
`stream`	`boolean`	`false`	`true` envia a resposta aos poucos, enquanto ela é escrita.

O corpo da requisição é JSON e precisa do cabeçalho Content-Type: application/json. A lista completa de campos está na página do endpoint. Chat Completions

A resposta

Uma chamada sem stream retorna um único objeto JSON quando a resposta está completa. Os textos e números abaixo são exemplos.

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

Campo	Tipo	Descrição
`id`	`string`	`chatcmpl-` seguido de 32 caracteres hexadecimais.
`object`	`string`	Sempre `chat.completion`.
`created`	`integer`	A hora da resposta em segundos Unix.
`model`	`string`	O id publicado do modelo que respondeu, mesmo quando você enviou um alias ou outra grafia.
`choices`	`array`	Sempre uma entrada, com `index` 0.
`choices[0].message.role`	`string`	Sempre `assistant`.
`choices[0].message.content`	`string \| null`	A resposta. Pode ser `null` quando a resposta traz `tool_calls`.
`choices[0].message.reasoning_content`	`string \| null`	O raciocínio do modelo antes da resposta, ou `null` quando não há nenhum.
`choices[0].message.tool_calls`	`array`	Presente apenas quando o modelo chama uma das ferramentas que você declarou.
`choices[0].finish_reason`	`string`	`stop` para uma resposta, `tool_calls` quando o modelo chama uma ferramenta.
`usage.prompt_tokens`	`integer`	Os tokens que o modelo leu para esta resposta. Em `shannon-2-*` e na família Shannon 3, isso pode ser mais do que o texto que você enviou.
`usage.completion_tokens`	`integer`	Os tokens que o modelo escreveu.
`usage.total_tokens`	`integer`	O total. A cobrança de um modelo Shannon é calculada a partir deste número.

usage contém contagens de tokens, não dinheiro. O que a chamada tirou do seu saldo aparece por requisição em Chaves e uso; como isso é calculado está em Limites e saldo. Limites e saldo
Toda resposta, inclusive um erro e um stream, tem o cabeçalho x-request-id. Se a sua requisição traz um cabeçalho x-request-id, o valor dele volta; caso contrário, o valor tem 12 caracteres hexadecimais. Guarde-o nos seus logs: ele identifica esta requisição específica.

A mesma chamada como stream

Defina stream como true para ler a resposta enquanto ela é escrita. O restante da requisição permanece igual.

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

Cada frame do stream é uma linha que começa com data: e contém um objeto JSON. Um frame, impresso em várias linhas:

Um frame

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

Frames, em ordem	delta	finish_reason
Enquanto o modelo raciocina. Zero ou mais frames.	`{"reasoning_content": "…"}`	`null`
A resposta, aos poucos. Zero ou mais frames.	`{"content": "…"}`	`null`
O último frame JSON. Ele também traz `usage`; você não precisa pedir.	`{}`	`"stop"`
O fim do stream: a linha `data: [DONE]`.

A resposta tem status 200 e content-type: text/event-stream. Cada frame é uma linha data: <json> seguida de uma linha vazia.
Uma linha : ping chega a cada 15 segundos. É um comentário que mantém a conexão aberta; os clientes SSE o ignoram.
Uma falha depois que o stream foi aberto chega como um frame data: {"error": {…}}. O status continua 200, então verifique os frames.

Streaming

Se a chamada falhar

Um erro é um objeto JSON com um error que contém type e message. Estas são as respostas que uma primeira chamada mais encontra.

Status	Tipo	Mensagem	O que significa
`401`	`authentication_error`	`Missing authentication`	Nenhuma chave chegou à API. Envie `Authorization: Bearer` seguido da sua chave.
`401`	`authentication_error`	`Invalid API key`	A chave não é a chave atual de uma conta. Copie-a novamente em Chaves e uso.
`400`	`invalid_request_error`	`unknown model: <id>`	`model` não é um id publicado. Use um id de Modelos e preços.
`422`	`invalid_request_error`	`Failed to deserialize the JSON body into the target type…`	Um campo tem o tipo JSON errado, ou falta `messages`.
`429`	`rate_limit_error`	`Quota exceeded. Upgrade your plan at shannon-ai.com/plan`	O orçamento de saída da requisição não cabe no seu saldo.

Tratamento de erros

Para onde ir em seguida

Modelos e preços — Escolha um modelo: ids, janelas de contexto e preços.
Chat Completions — Cada campo de requisição, campo de resposta e evento de stream do endpoint que você chamou.
Streaming — Os frames de um stream, linhas keep-alive e erros dentro de um stream.
Chamada de funções — Deixe o modelo chamar as suas funções.
Limites e saldo — O que uma requisição reserva e custa, e quantas requisições você pode enviar.
Playground da API — Teste requisições no navegador com a sua chave.