Inicio rápido

Haz una primera solicitud: obtén tu clave, envía un mensaje y lee la respuesta. La API habla los formatos de OpenAI y Anthropic, así que el SDK que ya usas funciona después de cambiar su URL base y su clave.

1. Obtén tu clave

Cada cuenta tiene una clave API. Inicia sesión, abre Claves y uso y cópiala. La clave funciona en todos los endpoints y todos los modelos. Claves y uso

2. Apunta tu cliente a la API

Todos los endpoints viven bajo una única URL base. Un SDK de OpenAI la toma con /v1 al final; un SDK de Anthropic la toma sin él, porque añade /v1/messages por sí mismo.

Cliente	URL base
SDK de OpenAI y clientes compatibles con OpenAI	`https://api.shannon-ai.com/v1`
SDK de Anthropic	`https://api.shannon-ai.com`

Tres endpoints producen texto. Llegan a los mismos modelos; elige aquel cuyo formato ya usa tu código.

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

3. Envía una primera solicitud

Envía un mensaje user a shannon-3 en el endpoint Chat Completions. Sustituye YOUR_API_KEY por tu clave.

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	Predeterminado	Descripción
`model`	`string`		El id del modelo que responde. Los ids se listan en Modelos y precios.
`messages`	`array`		La conversación hasta ahora: objetos con `role` y `content`. El último mensaje `user` es el prompt. Obligatorio.
`max_tokens`	`integer`	`4096`	El presupuesto de salida de la solicitud, de 1 a 65,536. La solicitud reserva esta cantidad de tu saldo y se cobra por lo que realmente usó.
`stream`	`boolean`	`false`	`true` envía la respuesta pieza a pieza mientras se escribe.

El cuerpo de la solicitud es JSON y necesita el header Content-Type: application/json. La lista completa de campos está en la página del endpoint. Chat Completions

La respuesta

Una llamada sin stream devuelve un único objeto JSON cuando la respuesta está completa. Los textos y números siguientes son ejemplos.

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	Descripción
`id`	`string`	`chatcmpl-` seguido de 32 caracteres hexadecimales.
`object`	`string`	Siempre `chat.completion`.
`created`	`integer`	La hora de la respuesta en segundos Unix.
`model`	`string`	El id publicado del modelo que respondió, también cuando enviaste un alias u otra forma de escribirlo.
`choices`	`array`	Siempre una entrada, con `index` 0.
`choices[0].message.role`	`string`	Siempre `assistant`.
`choices[0].message.content`	`string \| null`	La respuesta. Puede ser `null` cuando la respuesta lleva `tool_calls`.
`choices[0].message.reasoning_content`	`string \| null`	El razonamiento del modelo antes de su respuesta, o `null` cuando no hay ninguno.
`choices[0].message.tool_calls`	`array`	Presente solo cuando el modelo llama a una de las herramientas que declaraste.
`choices[0].finish_reason`	`string`	`stop` para una respuesta, `tool_calls` cuando el modelo llama a una herramienta.
`usage.prompt_tokens`	`integer`	Los tokens que el modelo leyó para esta respuesta. En `shannon-2-*` y la familia Shannon 3 pueden ser más que el texto que enviaste.
`usage.completion_tokens`	`integer`	Los tokens que escribió el modelo.
`usage.total_tokens`	`integer`	El total. El cobro de un modelo Shannon se calcula a partir de este número.

usage contiene recuentos de tokens, no dinero. Lo que la llamada tomó de tu saldo se muestra por solicitud en Claves y uso; cómo se calcula está en Límites y saldo. Límites y saldo
Toda respuesta, también un error y un stream, tiene el header x-request-id. Si tu solicitud lleva un header x-request-id, su valor vuelve; si no, el valor son 12 caracteres hexadecimales. Guárdalo en tus registros: identifica esta solicitud concreta.

La misma llamada como stream

Establece stream en true para leer la respuesta mientras se escribe. Todo lo demás en la solicitud queda 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 trama del stream es una línea que empieza con data: y contiene un objeto JSON. Una trama, impresa en varias líneas:

Una trama

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

Tramas, en orden	delta	finish_reason
Mientras el modelo razona. Cero o más tramas.	`{"reasoning_content": "…"}`	`null`
La respuesta, pieza por pieza. Cero o más tramas.	`{"content": "…"}`	`null`
La última trama JSON. También lleva `usage`; no hace falta pedirlo.	`{}`	`"stop"`
El final del stream: la línea `data: [DONE]`.

La respuesta tiene el estado 200 y content-type: text/event-stream. Cada trama es una línea data: <json> seguida de una línea vacía.
Cada 15 segundos llega una línea : ping. Es un comentario que mantiene abierta la conexión; los clientes SSE lo omiten.
Un fallo después de abrirse el stream llega como una trama data: {"error": {…}}. El estado sigue siendo 200, así que revisa las tramas.

Streaming

Si la llamada falla

Un error es un objeto JSON con un error que contiene type y message. Estas son las respuestas que más a menudo encuentra una primera llamada.

Estado	Tipo	Mensaje	Qué significa
`401`	`authentication_error`	`Missing authentication`	Ninguna clave llegó a la API. Envía `Authorization: Bearer` seguido de tu clave.
`401`	`authentication_error`	`Invalid API key`	La clave no es la clave actual de una cuenta. Vuelve a copiarla desde Claves y uso.
`400`	`invalid_request_error`	`unknown model: <id>`	`model` no es un id publicado. Usa un id de Modelos y precios.
`422`	`invalid_request_error`	`Failed to deserialize the JSON body into the target type…`	Un campo tiene un tipo JSON incorrecto, o falta `messages`.
`429`	`rate_limit_error`	`Quota exceeded. Upgrade your plan at shannon-ai.com/plan`	El presupuesto de salida de la solicitud no cabe en tu saldo.

Manejo de errores

Siguientes pasos

Modelos y precios — Elige un modelo: ids, ventanas de contexto y precios.
Chat Completions — Cada campo de solicitud, campo de respuesta y evento de stream del endpoint al que llamaste.
Streaming — Las tramas de un stream, las líneas de keep-alive y los errores dentro de un stream.
Llamadas a funciones — Deja que el modelo llame a tus funciones.
Límites y saldo — Qué reserva y cuánto cuesta una solicitud, y cuántas solicitudes puedes enviar.
Playground de API — Prueba solicitudes en el navegador con tu clave.