Recompte de tokens

Compta els tokens d'un text o d'una sol·licitud sencera abans d'enviar-la.

POST https://api.shannon-ai.com/v1/tokenize

POST https://api.shannon-ai.com/v1/messages/count_tokens

Tots dos endpoints compten amb el tokenitzador del model que indiques, i no s'executa cap model. Cobreixen els models open-weight hostejats. /v1/tokenize accepta un text pla o una conversa de Chat Completions. /v1/messages/count_tokens accepta una sol·licitud en el format Anthropic Messages, que és la crida que fan l'SDK d'Anthropic i Claude Code.

Comptar és gratuït. Una crida necessita la teva clau API, no descompta res del teu saldo i no apareix al teu registre d'ús.

Comptar un text

Envia model i text. El text es compta tal com és, sense cap format de xat al voltant.

import requests

response = requests.post(
    "https://api.shannon-ai.com/v1/tokenize",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
        "model": "DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP",
        "text": "Hello, world",
    },
)
print(response.json()["tokens"])

const response = await fetch("https://api.shannon-ai.com/v1/tokenize", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP",
    text: "Hello, world",
  }),
});

const { tokens } = await response.json();
console.log(tokens);

curl https://api.shannon-ai.com/v1/tokenize \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP",
    "text": "Hello, world"
  }'

200 Resposta

{
  "model": "DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP",
  "tokens": 3
}

Els nombres de les respostes d'aquesta pàgina són exemples. El mateix text dona un recompte diferent en un model diferent.

Comptar una sol·licitud de xat

Envia model i messages, amb tools quan la sol·licitud en té, exactament com els enviaries a /v1/chat/completions. La resposta és la mida de tota l'entrada.

import requests

request = {
    "model": "DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP",
    "messages": [
        {"role": "system", "content": "You are a concise assistant."},
        {"role": "user", "content": "What is the weather in Paris?"},
    ],
    "tools": [
        {
            "type": "function",
            "function": {
                "name": "get_weather",
                "description": "Current weather for a city",
                "parameters": {
                    "type": "object",
                    "properties": {"city": {"type": "string"}},
                    "required": ["city"],
                },
            },
        }
    ],
}

response = requests.post(
    "https://api.shannon-ai.com/v1/tokenize",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json=request,
)
print(response.json()["tokens"])

const request = {
  model: "DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP",
  messages: [
    { role: "system", content: "You are a concise assistant." },
    { role: "user", content: "What is the weather in Paris?" },
  ],
  tools: [
    {
      type: "function",
      function: {
        name: "get_weather",
        description: "Current weather for a city",
        parameters: {
          type: "object",
          properties: { city: { type: "string" } },
          required: ["city"],
        },
      },
    },
  ],
};

const response = await fetch("https://api.shannon-ai.com/v1/tokenize", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(request),
});

const { tokens } = await response.json();
console.log(tokens);

curl https://api.shannon-ai.com/v1/tokenize \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP",
    "messages": [
      {"role": "system", "content": "You are a concise assistant."},
      {"role": "user", "content": "What is the weather in Paris?"}
    ],
    "tools": [
      {
        "type": "function",
        "function": {
          "name": "get_weather",
          "description": "Current weather for a city",
          "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"]
          }
        }
      }
    ]
  }'

200 Resposta

{
  "model": "DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP",
  "tokens": 164
}

Camps de /v1/tokenize

Camp	Tipus	Descripció
`model`	`string`	Obligatori. Un id de model open-weight hostejat. Les majúscules i les minúscules es tracten igual.
`text`	`string`	Un text per comptar tal com és, sense format de xat. Fins a 4,000,000 bytes. Envia `text` o `messages`; quan hi són tots dos, es compta `text`.
`messages`	`array`	Missatges de xat en el format Chat Completions. Es compten com l'entrada completa d'una sol·licitud: cada missatge amb el format que la plantilla de xat del model hi posa al voltant.
`tools`	`array`	Definicions d'eines que s'inclouen al recompte. Es fan servir juntament amb `messages`.

La resposta és un objecte JSON amb aquests camps:

Camp	Tipus	Descripció
`model`	`string`	L'id del model per al qual s'ha fet el recompte, amb la seva grafia publicada.
`tokens`	`integer`	Amb `text`: els tokens del text. Amb `messages`: els tokens de tota l'entrada, imatges incloses.

Comptar una sol·licitud Messages

Envia el cos que enviaries a /v1/messages: model, messages, i system i tools si els fas servir. Els SDK oficials d'Anthropic criden aquest endpoint amb messages.count_tokens.

import anthropic

client = anthropic.Anthropic(
    api_key="YOUR_API_KEY",
    base_url="https://api.shannon-ai.com",
)

count = client.messages.count_tokens(
    model="DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP",
    system="You are a concise assistant.",
    messages=[
        {"role": "user", "content": "Summarise the attached report."}
    ],
)
print(count.input_tokens)

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  apiKey: "YOUR_API_KEY",
  baseURL: "https://api.shannon-ai.com",
});

const count = await client.messages.countTokens({
  model: "DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP",
  system: "You are a concise assistant.",
  messages: [
    { role: "user", content: "Summarise the attached report." },
  ],
});
console.log(count.input_tokens);

curl https://api.shannon-ai.com/v1/messages/count_tokens \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP",
    "system": "You are a concise assistant.",
    "messages": [
      {"role": "user", "content": "Summarise the attached report."}
    ]
  }'

200 Resposta

{
  "input_tokens": 21
}

Camps de /v1/messages/count_tokens

Camp	Tipus	Descripció
`model`	`string`	Obligatori. Un id de model open-weight hostejat.
`messages`	`array`	Obligatori. Missatges en el format Anthropic Messages. Es compten els blocs `text`, `image`, `tool_use` i `tool_result`.
`system`	`string \| array`	El prompt de sistema: una cadena o una matriu de blocs de text.
`tools`	`array`	Definicions d'eines amb `name`, `description` i `input_schema`.

S'accepten per compatibilitat, sense efecte sobre el recompte: tool_choice, max_tokens, temperature, top_p, stop_sequences, stream, thinking. Pots passar el cos d'una sol·licitud real sense canvis.

La resposta és un objecte JSON amb aquests camps:

Camp	Tipus	Descripció
`input_tokens`	`integer`	Els tokens de tota l'entrada: prompt de sistema, missatges, eines i imatges.

Models admesos

Tots dos endpoints compten per als models open-weight hostejats. GET /v1/models llista /v1/tokenize i /v1/messages/count_tokens als endpoints de cada model que els admet. Qualsevol altre valor de model, inclosos els ids Shannon, es respon amb 400.

DeepSeek-V4-Pro-0813-3BIT-REAP
GLM-5.2-3BIT-REAP
Kimi-K3-3BIT-REAP
Nemotron3Ultra-3BIT-REAP
MiniMax-M3-3BIT-REAP
DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP
Kimi-K2.6-W4A16-AUTOROUND-REAP
Laguna-S-2.1-W4A16-AUTOROUND-REAP
inkling-W4A16-AUTOROUND-REAP
MiMo-V2.5-Pro-W8A16
MiMo-V2.5-W8A16
Hy3-W8A16

Per a un model Shannon, llegeix els recomptes de tokens de l'objecte usage d'una resposta.

Com es fa el recompte

Cada model es compta amb el seu propi tokenitzador i la seva pròpia plantilla de xat. No es fa servir cap estimació a partir de caràcters o paraules.

Què es compta	Regla
Un text	Els tokens de la cadena tal com s'envia. Una cadena buida compta 0.
Missatges	Els missatges i les eines es disposen amb la plantilla de xat pròpia del model, fins al punt on comença la resposta, i es compta tot aquest prompt.
Rols	Es compten els missatges `system`, `user`, `assistant` i `tool`. `developer` es compta com a `system`. Un missatge sense contingut ni crida d'eina no afegeix res.
Crides d'eina i resultats	Les crides d'eina dels torns anteriors de l'assistent i els seus resultats formen part del recompte, als dos endpoints.
Imatges	Una imatge enviada dins del cos (base64 o una URL `data:`) afegeix un token per cada tros de 28 × 28 píxels: `ceil(width / 28) × ceil(height / 28)`. Una imatge donada com a URL `http(s)` no és descarregada per aquests endpoints i compta 1,024.

Exemple: una imatge d'1,024 × 768 píxels compta ceil(1024 / 28) × ceil(768 / 28) = 37 × 28 = 1,036 tokens.

El recompte i el que es cobra una sol·licitud

El recompte d'una sol·licitud sencera es fa de la mateixa manera que el recompte d'entrada d'una sol·licitud real amb el mateix model, missatges i eines. Una resposta informa aquest nombre com a usage.prompt_tokens a Chat Completions, com a usage.input_tokens a Responses, i com a usage.input_tokens més usage.cache_read_input_tokens a Messages.

El recompte és l'entrada abans del descompte d'entrada en cache. Una sol·licitud real pot llegir part d'aquesta entrada de la cache i facturar aquesta part a la tarifa de cache. Caching de prompts
Una imatge donada com a URL http(s) compta 1,024 aquí. Una sol·licitud real descarrega la imatge i la compta a partir de la seva mida en píxels, així que els dos nombres poden ser diferents. Envia la imatge com a base64 per obtenir el mateix nombre.
La sortida no forma part del recompte. La resposta d'una sol·licitud real es factura a més com a tokens de sortida, raonament inclòs.
Un recompte de text no té format de xat. Fes-lo servir per mesurar un document o una part d'un prompt, i la forma messages per mesurar una sol·licitud.

Per convertir un recompte en un cost, multiplica'l pel preu d'entrada del model per 1M de tokens. Models i preus

Límits

Límit	Valor	Per sobre
Longitud de `text`	4,000,000 bytes (UTF-8)	`413` amb el missatge `text too long`
Cos de la sol·licitud	32 MiB	`413`
Per sol·licitud	Un text o una conversa	Per comptar diversos textos, envia una sol·licitud per text.

Les crides de recompte no compten per al límit de 120 sol·licituds per minut. Límits i saldo

Errors

Estat	Tipus	Missatge	Quan
`400`	`invalid_request_error`	`tokenize is available for the hosted open models; unknown model: <model>`	`/v1/tokenize` amb un `model` que no és un id open-weight hostejat.
`400`	`invalid_request_error`	`count_tokens is available for the hosted open models; unknown model: <model>`	`/v1/messages/count_tokens` amb un `model` que no és un id open-weight hostejat, o sense `model`.
`400`	`invalid_request_error`	send `text` or `messages`	`/v1/tokenize` sense `text` ni `messages`.
`401`	`authentication_error`	`Missing authentication / Invalid API key`	No s'ha enviat cap clau, o la clau no és vàlida.
`413`	`invalid_request_error`	`text too long`	`text` és més llarg que 4,000,000 bytes. Un cos de més de 32 MiB també es respon amb `413`.
`415`	`invalid_request_error`	Expected request with `Content-Type: application/json`	La sol·licitud no té un tipus de contingut JSON.
`422`	`invalid_request_error`	`Failed to deserialize the JSON body into the target type: …`	Falta un camp obligatori (`model` a `/v1/tokenize`, `messages` a `/v1/messages/count_tokens`) o un camp té el tipus incorrecte.
`503`	`api_error`	`token counting is temporarily unavailable for this model`	El recompte no es pot fer per a aquest model en aquest moment. Torna-ho a provar més tard.

/v1/tokenize retorna els errors amb la forma d'OpenAI. A /v1/messages/count_tokens, els errors de l'endpoint mateix (400 pel model, 503) vénen amb la forma d'Anthropic, i 401, 413, 415 i 422 vénen amb la forma d'OpenAI. Llegeix primer el codi d'estat, i després error.type i error.message, que són presents a les dues formes.

400 /v1/tokenize

{
  "error": {
    "type": "invalid_request_error",
    "message": "tokenize is available for the hosted open models; unknown model: shannon-3"
  }
}

400 /v1/messages/count_tokens

{
  "type": "error",
  "error": {
    "type": "invalid_request_error",
    "message": "count_tokens is available for the hosted open models; unknown model: shannon-3"
  }
}