Tokens tellen

Tel de tokens van een tekst of van een hele aanvraag voordat je die verstuurt.

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

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

Beide endpoints tellen met de tokenizer van het model dat je noemt, en er draait geen model. Ze gelden voor de gehoste open-weight modellen. /v1/tokenize accepteert een gewone tekst of een Chat Completions-gesprek. /v1/messages/count_tokens accepteert een aanvraag in het Anthropic Messages-formaat, de call die de Anthropic-SDK en Claude Code doen.

Tellen is gratis. Een call heeft je API-sleutel nodig, haalt niets van je saldo af en verschijnt niet in je gebruikslog.

Een tekst tellen

Stuur model en text. De tekst wordt geteld zoals hij is, zonder chatopmaak eromheen.

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 Antwoord

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

De getallen in de antwoorden op deze pagina zijn voorbeelden. Dezelfde tekst geeft op een ander model een andere telling.

Een chataanvraag tellen

Stuur model en messages, met tools als de aanvraag die heeft, precies zoals je ze naar /v1/chat/completions zou sturen. Het antwoord is de grootte van de hele input.

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 Antwoord

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

Velden van /v1/tokenize

Veld	Type	Beschrijving
`model`	`string`	Vereist. Een id van een gehost open-weight model. Hoofdletters en kleine letters worden gelijk behandeld.
`text`	`string`	Een tekst die wordt geteld zoals hij is, zonder chatopmaak. Tot 4,000,000 bytes. Stuur `text` of `messages`; als beide aanwezig zijn, wordt `text` geteld.
`messages`	`array`	Chatberichten in het Chat Completions-formaat. Ze worden geteld als de volledige input van een aanvraag: elk bericht met de opmaak die het chatsjabloon van het model eromheen zet.
`tools`	`array`	Tooldefinities die in de telling worden opgenomen. Gebruikt samen met `messages`.

Het antwoord is een JSON-object met deze velden:

Veld	Type	Beschrijving
`model`	`string`	De model-id waarvoor de telling is gemaakt, in zijn gepubliceerde schrijfwijze.
`tokens`	`integer`	Met `text`: de tokens van de tekst. Met `messages`: de tokens van de hele input, afbeeldingen inbegrepen.

Een Messages-aanvraag tellen

Stuur de body die je naar /v1/messages zou sturen: model, messages, en system en tools als je ze gebruikt. De officiële Anthropic-SDK's roepen dit endpoint aan via 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 Antwoord

{
  "input_tokens": 21
}

Velden van /v1/messages/count_tokens

Veld	Type	Beschrijving
`model`	`string`	Vereist. Een id van een gehost open-weight model.
`messages`	`array`	Vereist. Berichten in het Anthropic Messages-formaat. Blokken van `text`, `image`, `tool_use` en `tool_result` worden geteld.
`system`	`string \| array`	De systeemprompt: een string of een array van tekstblokken.
`tools`	`array`	Tooldefinities met `name`, `description` en `input_schema`.

Geaccepteerd voor compatibiliteit, zonder effect op de telling: tool_choice, max_tokens, temperature, top_p, stop_sequences, stream, thinking. Je kunt de body van een echte aanvraag ongewijzigd doorgeven.

Het antwoord is een JSON-object met deze velden:

Veld	Type	Beschrijving
`input_tokens`	`integer`	De tokens van de hele input: systeemprompt, berichten, tools en afbeeldingen.

Ondersteunde modellen

Beide endpoints tellen voor de gehoste open-weight modellen. GET /v1/models vermeldt /v1/tokenize en /v1/messages/count_tokens in de endpoints van elk model dat ze ondersteunt. Elke andere model-waarde, de Shannon-id's inbegrepen, wordt beantwoord met 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

Lees voor een Shannon-model de tokenaantallen uit het usage-object van een antwoord.

Hoe de telling wordt gemaakt

Elk model wordt geteld met zijn eigen tokenizer en zijn eigen chatsjabloon. Er wordt geen schatting op basis van tekens of woorden gebruikt.

Wat er wordt geteld	Regel
Een tekst	De tokens van de string zoals verstuurd. Een lege string telt als 0.
Berichten	De berichten en tools worden opgemaakt met het eigen chatsjabloon van het model, tot het punt waar het antwoord begint, en die hele prompt wordt geteld.
Rollen	Berichten met `system`, `user`, `assistant` en `tool` worden geteld. `developer` wordt geteld als `system`. Een bericht zonder content en zonder toolaanroep voegt niets toe.
Toolaanroepen en resultaten	Toolaanroepen van eerdere assistentbeurten en hun resultaten maken deel uit van de telling, op beide endpoints.
Afbeeldingen	Een afbeelding die in de body wordt meegestuurd (base64 of een `data:`-URL) voegt één token toe per patch van 28 × 28 pixels: `ceil(width / 28) × ceil(height / 28)`. Een afbeelding die als `http(s)`-URL is opgegeven, wordt door deze endpoints niet gedownload en telt als 1,024.

Voorbeeld: een afbeelding van 1,024 × 768 pixels telt als ceil(1024 / 28) × ceil(768 / 28) = 37 × 28 = 1,036 tokens.

De telling en wat een aanvraag kost

De telling van een hele aanvraag wordt op dezelfde manier gemaakt als de inputtelling van een echte aanvraag met hetzelfde model, dezelfde berichten en tools. Een antwoord meldt dat getal als usage.prompt_tokens bij Chat Completions, als usage.input_tokens bij Responses, en als usage.input_tokens plus usage.cache_read_input_tokens bij Messages.

De telling is de input vóór de korting voor gecachete input. Een echte aanvraag kan een deel van die input uit de cache lezen en dat deel tegen het gecachete tarief factureren. Prompt-caching
Een afbeelding die als http(s)-URL is opgegeven, telt hier als 1,024. Een echte aanvraag downloadt de afbeelding en telt haar aan de hand van de grootte in pixels, dus de twee getallen kunnen verschillen. Stuur de afbeelding als base64 om hetzelfde getal te krijgen.
Output hoort niet bij de telling. Het antwoord van een echte aanvraag wordt daarbovenop als outputtokens gefactureerd, redenering inbegrepen.
Een text-telling heeft geen chatopmaak. Gebruik haar om een document of een deel van een prompt te meten, en de messages-vorm om een aanvraag te meten.

Om een telling om te zetten in kosten, vermenigvuldig je haar met de inputprijs van het model per 1M tokens. Modellen en prijzen

Limieten

Limiet	Waarde	Daarboven
Lengte van `text`	4,000,000 bytes (UTF-8)	`413` met de melding `text too long`
Aanvraagbody	32 MiB	`413`
Per aanvraag	Eén tekst of één gesprek	Stuur één aanvraag per tekst om meerdere teksten te tellen.

Telcalls tellen niet mee voor de limiet van 120 aanvragen per minuut. Limieten en saldo

Fouten

Status	Type	Melding	Wanneer
`400`	`invalid_request_error`	`tokenize is available for the hosted open models; unknown model: <model>`	`/v1/tokenize` met een `model` dat geen id van een gehost open-weight model is.
`400`	`invalid_request_error`	`count_tokens is available for the hosted open models; unknown model: <model>`	`/v1/messages/count_tokens` met een `model` dat geen id van een gehost open-weight model is, of zonder `model`.
`400`	`invalid_request_error`	send `text` or `messages`	`/v1/tokenize` zonder `text` en zonder `messages`.
`401`	`authentication_error`	`Missing authentication / Invalid API key`	Er is geen sleutel gestuurd, of de sleutel is niet geldig.
`413`	`invalid_request_error`	`text too long`	`text` is langer dan 4,000,000 bytes. Een body van meer dan 32 MiB wordt ook beantwoord met `413`.
`415`	`invalid_request_error`	Expected request with `Content-Type: application/json`	De aanvraag heeft geen JSON-contenttype.
`422`	`invalid_request_error`	`Failed to deserialize the JSON body into the target type: …`	Een verplicht veld ontbreekt (`model` op `/v1/tokenize`, `messages` op `/v1/messages/count_tokens`) of een veld heeft het verkeerde type.
`503`	`api_error`	`token counting is temporarily unavailable for this model`	De telling kan op dit moment niet voor dit model worden gemaakt. Probeer het later opnieuw.

/v1/tokenize geeft fouten in de OpenAI-vorm terug. Op /v1/messages/count_tokens komen de fouten van het endpoint zelf (400 voor het model, 503) in de Anthropic-vorm, en 401, 413, 415 en 422 in de OpenAI-vorm. Lees eerst de statuscode, daarna error.type en error.message, die in beide vormen aanwezig zijn.

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