Token-telling

Tell tokens i en tekst eller i en hel forespørsel før du sender den.

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

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

Begge endepunktene teller med tokenizeren til modellen du oppgir, og ingen modell kjører. De dekker de hostede åpne vektmodellene. /v1/tokenize tar en ren tekst eller en Chat Completions-samtale. /v1/messages/count_tokens tar en forespørsel i Anthropic Messages-formatet, som er kallet Anthropic-SDK-en og Claude Code gjør.

Telling er gratis. Et kall krever API-nøkkelen din, tar ingenting fra saldoen din og vises ikke i bruksloggen din.

Tell en tekst

Send model og text. Teksten telles som den er, uten chat-formatering rundt.

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 Svar

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

Tallene i svarene på denne siden er eksempler. Den samme teksten gir en annen telling på en annen modell.

Tell en chat-forespørsel

Send model og messages, med tools når forespørselen har dem, nøyaktig slik du ville sendt dem til /v1/chat/completions. Svaret er størrelsen på hele inputen.

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 Svar

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

Felt i /v1/tokenize

Felt	Type	Beskrivelse
`model`	`string`	Påkrevd. En id for en hostet åpen vektmodell. Store og små bokstaver behandles likt.
`text`	`string`	En tekst som telles som den er, uten chat-formatering. Opptil 4,000,000 byte. Send `text` eller `messages`; når begge finnes, telles `text`.
`messages`	`array`	Chat-meldinger i Chat Completions-formatet. De telles som hele inputen i en forespørsel: hver melding med formateringen modellens chat-mal legger rundt den.
`tools`	`array`	Verktøydefinisjoner som skal tas med i tellingen. Brukes sammen med `messages`.

Svaret er et JSON-objekt med disse feltene:

Felt	Type	Beskrivelse
`model`	`string`	Modell-id-en tellingen ble gjort for, i publisert skrivemåte.
`tokens`	`integer`	Med `text`: tokens i teksten. Med `messages`: tokens i hele inputen, bilder inkludert.

Tell en Messages-forespørsel

Send kroppen du ville sendt til /v1/messages: model, messages, og system og tools når du bruker dem. De offisielle Anthropic-SDK-ene kaller dette endepunktet gjennom 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 Svar

{
  "input_tokens": 21
}

Felt i /v1/messages/count_tokens

Felt	Type	Beskrivelse
`model`	`string`	Påkrevd. En id for en hostet åpen vektmodell.
`messages`	`array`	Påkrevd. Meldinger i Anthropic Messages-formatet. Blokkene `text`, `image`, `tool_use` og `tool_result` telles.
`system`	`string \| array`	System prompten: en streng eller en matrise av tekstblokker.
`tools`	`array`	Verktøydefinisjoner med `name`, `description` og `input_schema`.

Godtatt for kompatibilitet, uten effekt på tellingen: tool_choice, max_tokens, temperature, top_p, stop_sequences, stream, thinking. Du kan sende kroppen fra en ekte forespørsel uendret.

Svaret er et JSON-objekt med disse feltene:

Felt	Type	Beskrivelse
`input_tokens`	`integer`	Tokens i hele inputen: system prompt, meldinger, verktøy og bilder.

Støttede modeller

Begge endepunktene teller for de hostede åpne vektmodellene. GET /v1/models lister /v1/tokenize og /v1/messages/count_tokens i endpoints for hver modell som støtter dem. Enhver annen model-verdi, Shannon-id-er inkludert, besvares med 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

For en Shannon-modell leser du tokenantallene fra usage-objektet i et svar.

Hvordan tellingen gjøres

Hver modell telles med sin egen tokenizer og sin egen chat-mal. Ingen estimat fra tegn eller ord brukes.

Hva som telles	Regel
En tekst	Tokens i strengen slik den ble sendt. En tom streng teller 0.
Meldinger	Meldingene og verktøyene legges opp med modellens egen chat-mal, fram til punktet der svaret begynner, og hele den prompten telles.
Roller	Meldinger med `system`, `user`, `assistant` og `tool` telles. `developer` telles som `system`. En melding uten innhold og uten verktøykall legger ikke til noe.
Verktøykall og resultater	Verktøykall fra tidligere assistentrunder og resultatene av dem er en del av tellingen, på begge endepunktene.
Bilder	Et bilde sendt inne i kroppen (base64 eller en `data:`-URL) legger til ett token per rute på 28 × 28 piksler: `ceil(width / 28) × ceil(height / 28)`. Et bilde oppgitt som `http(s)`-URL lastes ikke ned av disse endepunktene og teller 1,024.

Eksempel: et bilde på 1,024 × 768 piksler teller ceil(1024 / 28) × ceil(768 / 28) = 37 × 28 = 1,036 tokens.

Tellingen og hva en forespørsel belastes

Tellingen av en hel forespørsel gjøres på samme måte som inputtellingen i en ekte forespørsel med samme modell, meldinger og verktøy. Et svar rapporterer det tallet som usage.prompt_tokens på Chat Completions, som usage.input_tokens på Responses, og som usage.input_tokens pluss usage.cache_read_input_tokens på Messages.

Tellingen er inputen før rabatten for cachet input. En ekte forespørsel kan lese en del av inputen fra cachen og fakturere den delen til cachet sats. Prompt-caching
Et bilde oppgitt som http(s)-URL teller 1,024 her. En ekte forespørsel laster ned bildet og teller det ut fra størrelsen i piksler, så de to tallene kan være forskjellige. Send bildet som base64 for å få det samme tallet.
Output er ikke en del av tellingen. Svaret på en ekte forespørsel faktureres som output-tokens i tillegg, resonnering inkludert.
En text-telling har ingen chat-formatering. Bruk den til å måle et dokument eller en del av en prompt, og messages-formen til å måle en forespørsel.

For å gjøre en telling om til en kostnad ganger du den med modellens inputpris per 1M tokens. Modeller og priser

Grenser

Grense	Verdi	Over den
Lengden på `text`	4,000,000 byte (UTF-8)	`413` med meldingen `text too long`
Forespørselskropp	32 MiB	`413`
Per forespørsel	Én tekst eller én samtale	Send én forespørsel per tekst for å telle flere tekster.

Tellekall teller ikke mot grensen på 120 forespørsler per minutt. Grenser og saldo

Feil

Status	Type	Melding	Når
`400`	`invalid_request_error`	`tokenize is available for the hosted open models; unknown model: <model>`	`/v1/tokenize` med en `model` som ikke er en id for en hostet åpen vektmodell.
`400`	`invalid_request_error`	`count_tokens is available for the hosted open models; unknown model: <model>`	`/v1/messages/count_tokens` med en `model` som ikke er en id for en hostet åpen vektmodell, eller uten `model`.
`400`	`invalid_request_error`	send `text` or `messages`	`/v1/tokenize` uten verken `text` eller `messages`.
`401`	`authentication_error`	`Missing authentication / Invalid API key`	Ingen nøkkel ble sendt, eller nøkkelen er ikke gyldig.
`413`	`invalid_request_error`	`text too long`	`text` er lengre enn 4,000,000 byte. En kropp over 32 MiB besvares også med `413`.
`415`	`invalid_request_error`	Expected request with `Content-Type: application/json`	Forespørselen har ingen JSON-innholdstype.
`422`	`invalid_request_error`	`Failed to deserialize the JSON body into the target type: …`	Et påkrevd felt mangler (`model` på `/v1/tokenize`, `messages` på `/v1/messages/count_tokens`), eller et felt har feil type.
`503`	`api_error`	`token counting is temporarily unavailable for this model`	Tellingen kan ikke gjøres for denne modellen for øyeblikket. Prøv igjen senere.

/v1/tokenize returnerer feil i OpenAI-formen. På /v1/messages/count_tokens kommer endepunktets egne feil (400 for modellen, 503) i Anthropic-formen, og 401, 413, 415 og 422 kommer i OpenAI-formen. Les statuskoden først, deretter error.type og error.message, som finnes i begge former.

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