Numărarea token-urilor

Numără token-urile unui text sau ale unei cereri întregi înainte de a o trimite.

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

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

Ambele endpoint-uri numără cu tokenizerul modelului pe care îl numești și nu rulează niciun model. Acoperă modelele open-weight găzduite. /v1/tokenize primește un text simplu sau o conversație Chat Completions. /v1/messages/count_tokens primește o cerere în formatul Anthropic Messages, adică apelul pe care îl fac SDK-ul Anthropic și Claude Code.

Numărarea este gratuită. Un apel cere cheia ta API, nu ia nimic din soldul tău și nu apare în jurnalul tău de utilizare.

Numărarea unui text

Trimite model și text. Textul este numărat așa cum este, fără formatare de chat în jurul lui.

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 Răspuns

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

Numerele din răspunsurile de pe această pagină sunt exemple. Același text dă o numărătoare diferită pe un alt model.

Numărarea unei cereri de chat

Trimite model și messages, cu tools când cererea le are, exact cum le-ai trimite la /v1/chat/completions. Răspunsul este mărimea întregii intrări.

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 Răspuns

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

Câmpurile lui /v1/tokenize

Câmp	Tip	Descriere
`model`	`string`	Obligatoriu. Un id de model open-weight găzduit. Majusculele și minusculele sunt tratate la fel.
`text`	`string`	Un text de numărat așa cum este, fără formatare de chat. Până la 4,000,000 de octeți. Trimite `text` sau `messages`; când sunt prezente ambele, se numără `text`.
`messages`	`array`	Mesaje de chat în formatul Chat Completions. Sunt numărate ca întreaga intrare a unei cereri: fiecare mesaj cu formatarea pe care o pune șablonul de chat al modelului în jurul lui.
`tools`	`array`	Definiții de instrumente de inclus în numărătoare. Folosit împreună cu `messages`.

Răspunsul este un obiect JSON cu aceste câmpuri:

Câmp	Tip	Descriere
`model`	`string`	Id-ul modelului pentru care s-a făcut numărătoarea, în scrierea lui publicată.
`tokens`	`integer`	Cu `text`: token-urile textului. Cu `messages`: token-urile întregii intrări, inclusiv imaginile.

Numărarea unei cereri Messages

Trimite corpul pe care l-ai trimite la /v1/messages: model, messages, iar system și tools când le folosești. SDK-urile oficiale Anthropic apelează acest endpoint prin 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 Răspuns

{
  "input_tokens": 21
}

Câmpurile lui /v1/messages/count_tokens

Câmp	Tip	Descriere
`model`	`string`	Obligatoriu. Un id de model open-weight găzduit.
`messages`	`array`	Obligatoriu. Mesaje în formatul Anthropic Messages. Se numără blocurile `text`, `image`, `tool_use` și `tool_result`.
`system`	`string \| array`	System prompt-ul: un șir sau un array de blocuri de text.
`tools`	`array`	Definiții de instrumente cu `name`, `description` și `input_schema`.

Acceptate pentru compatibilitate, fără efect asupra numărătorii: tool_choice, max_tokens, temperature, top_p, stop_sequences, stream, thinking. Poți transmite neschimbat corpul unei cereri reale.

Răspunsul este un obiect JSON cu aceste câmpuri:

Câmp	Tip	Descriere
`input_tokens`	`integer`	Token-urile întregii intrări: system prompt, mesaje, instrumente și imagini.

Modele acceptate

Ambele endpoint-uri numără pentru modelele open-weight găzduite. GET /v1/models listează /v1/tokenize și /v1/messages/count_tokens în endpoints pentru fiecare model care le acceptă. Orice altă valoare model, inclusiv id-urile Shannon, primește răspuns 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

Pentru un model Shannon, citește numărul de token-uri din obiectul usage al unui răspuns.

Cum se face numărătoarea

Fiecare model este numărat cu tokenizerul propriu și cu propriul șablon de chat. Nu se folosește nicio estimare după caractere sau cuvinte.

Ce se numără	Regulă
Un text	Token-urile șirului așa cum a fost trimis. Un șir gol contează 0.
Mesaje	Mesajele și instrumentele sunt așezate cu șablonul de chat propriu modelului, până în punctul în care începe răspunsul, iar întregul prompt este numărat.
Roluri	Mesajele `system`, `user`, `assistant` și `tool` sunt numărate. `developer` este numărat ca `system`. Un mesaj fără conținut și fără apel de instrument nu adaugă nimic.
Apeluri de instrumente și rezultate	Apelurile de instrumente din rundele anterioare ale asistentului și rezultatele lor fac parte din numărătoare, pe ambele endpoint-uri.
Imagini	O imagine trimisă în corp (base64 sau un URL `data:`) adaugă un token pentru fiecare porțiune de 28 × 28 pixeli: `ceil(width / 28) × ceil(height / 28)`. O imagine dată ca URL `http(s)` nu este descărcată de aceste endpoint-uri și contează 1,024.

Exemplu: o imagine de 1,024 × 768 pixeli contează ceil(1024 / 28) × ceil(768 / 28) = 37 × 28 = 1,036 token-uri.

Numărătoarea și ce se taxează la o cerere

Numărătoarea unei cereri întregi se face la fel ca numărătoarea intrării unei cereri reale cu același model, aceleași mesaje și aceleași instrumente. Un răspuns raportează acel număr ca usage.prompt_tokens pe Chat Completions, ca usage.input_tokens pe Responses și ca usage.input_tokens plus usage.cache_read_input_tokens pe Messages.

Numărătoarea este intrarea înainte de reducerea pentru intrare din cache. O cerere reală poate citi o parte din acea intrare din cache și poate taxa acea parte la tariful pentru cache. Caching de prompt
O imagine dată ca URL http(s) contează aici 1,024. O cerere reală descarcă imaginea și o numără după mărimea ei în pixeli, deci cele două numere pot diferi. Trimite imaginea ca base64 pentru a obține același număr.
Ieșirea nu face parte din numărătoare. Răspunsul unei cereri reale se taxează suplimentar ca token-uri de ieșire, inclusiv raționamentul.
O numărătoare pentru text nu are formatare de chat. Folosește-o pentru a măsura un document sau o parte de prompt, iar forma messages pentru a măsura o cerere.

Ca să transformi o numărătoare în cost, înmulțește-o cu prețul de intrare al modelului per 1M token-uri. Modele și prețuri

Limite

Limită	Valoare	Peste ea
Lungimea lui `text`	4,000,000 de octeți (UTF-8)	`413` cu mesajul `text too long`
Corpul cererii	32 MiB	`413`
Per cerere	Un text sau o conversație	Trimite o cerere pentru fiecare text, ca să numeri mai multe texte.

Apelurile de numărare nu se includ în limita de 120 de cereri pe minut. Limite și sold

Erori

Status	Tip	Mesaj	Când
`400`	`invalid_request_error`	`tokenize is available for the hosted open models; unknown model: <model>`	`/v1/tokenize` cu un `model` care nu este un id de model open-weight găzduit.
`400`	`invalid_request_error`	`count_tokens is available for the hosted open models; unknown model: <model>`	`/v1/messages/count_tokens` cu un `model` care nu este un id de model open-weight găzduit sau fără `model`.
`400`	`invalid_request_error`	send `text` or `messages`	`/v1/tokenize` fără `text` și fără `messages`.
`401`	`authentication_error`	`Missing authentication / Invalid API key`	Nu s-a trimis nicio cheie sau cheia nu este validă.
`413`	`invalid_request_error`	`text too long`	`text` are peste 4,000,000 de octeți. Un corp peste 32 MiB primește și el răspuns `413`.
`415`	`invalid_request_error`	Expected request with `Content-Type: application/json`	Cererea nu are un content type JSON.
`422`	`invalid_request_error`	`Failed to deserialize the JSON body into the target type: …`	Lipsește un câmp obligatoriu (`model` pe `/v1/tokenize`, `messages` pe `/v1/messages/count_tokens`) sau un câmp are tipul greșit.
`503`	`api_error`	`token counting is temporarily unavailable for this model`	Numărătoarea nu poate fi făcută pentru acest model în acest moment. Încearcă din nou mai târziu.

/v1/tokenize returnează erorile în forma OpenAI. Pe /v1/messages/count_tokens, erorile proprii ale endpoint-ului (400 pentru model, 503) vin în forma Anthropic, iar 401, 413, 415 și 422 vin în forma OpenAI. Citește mai întâi codul de status, apoi error.type și error.message, care sunt prezente în ambele forme.

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