Tokens tel

Tel die tokens van 'n teks of van 'n hele versoek voordat jy dit stuur.

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

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

Albei eindpunte tel met die tokenizer van die model wat jy noem, en geen model loop nie. Hulle dek die gehuisveste oopgewig-modelle. /v1/tokenize neem 'n gewone teks of 'n Chat Completions-gesprek. /v1/messages/count_tokens neem 'n versoek in die Anthropic Messages-formaat, wat die oproep is wat die Anthropic-SDK en Claude Code maak.

Tel is gratis. 'n Oproep het jou API-sleutel nodig, neem niks van jou balans af nie en verskyn nie in jou gebruiklog nie.

Tel 'n teks

Stuur model en text. Die teks word getel soos dit is, sonder klets-formatering daarom.

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
}

Die getalle in die antwoorde op hierdie bladsy is voorbeelde. Dieselfde teks gee 'n ander telling op 'n ander model.

Tel 'n klets-versoek

Stuur model en messages, met tools wanneer die versoek hulle het, presies soos jy hulle na /v1/chat/completions sou stuur. Die antwoord is die grootte van die hele inset.

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
}

Velde van /v1/tokenize

Veld	Tipe	Beskrywing
`model`	`string`	Vereis. 'n Id van 'n gehuisveste oopgewig-model. Hoof- en kleinletters word eenders hanteer.
`text`	`string`	'n Teks om te tel soos dit is, sonder klets-formatering. Tot 4,000,000 grepe. Stuur `text` of `messages`; wanneer albei teenwoordig is, word `text` getel.
`messages`	`array`	Klets-boodskappe in die Chat Completions-formaat. Hulle word getel as die volle inset van 'n versoek: elke boodskap met die formatering wat die model se klets-sjabloon daarom sit.
`tools`	`array`	Gereedskapdefinisies om in die telling in te sluit. Gebruik saam met `messages`.

Die antwoord is 'n JSON-objek met hierdie velde:

Veld	Tipe	Beskrywing
`model`	`string`	Die model-id waarvoor die telling gemaak is, in sy gepubliseerde spelling.
`tokens`	`integer`	Met `text`: die tokens van die teks. Met `messages`: die tokens van die hele inset, beelde ingesluit.

Tel 'n Messages-versoek

Stuur die liggaam wat jy na /v1/messages sou stuur: model, messages, en system en tools wanneer jy hulle gebruik. Die amptelike Anthropic-SDK's roep hierdie eindpunt deur messages.count_tokens aan.

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
}

Velde van /v1/messages/count_tokens

Veld	Tipe	Beskrywing
`model`	`string`	Vereis. 'n Id van 'n gehuisveste oopgewig-model.
`messages`	`array`	Vereis. Boodskappe in die Anthropic Messages-formaat. `text`-, `image`-, `tool_use`- en `tool_result`-blokke word getel.
`system`	`string \| array`	Die stelselprompt: 'n string of 'n skikking teksblokke.
`tools`	`array`	Gereedskapdefinisies met `name`, `description` en `input_schema`.

Aanvaar vir versoenbaarheid, sonder effek op die telling: tool_choice, max_tokens, temperature, top_p, stop_sequences, stream, thinking. Jy kan die liggaam van 'n werklike versoek ongewysig deurgee.

Die antwoord is 'n JSON-objek met hierdie velde:

Veld	Tipe	Beskrywing
`input_tokens`	`integer`	Die tokens van die hele inset: stelselprompt, boodskappe, gereedskap en beelde.

Ondersteunde modelle

Albei eindpunte tel vir die gehuisveste oopgewig-modelle. GET /v1/models lys /v1/tokenize en /v1/messages/count_tokens in die endpoints van elke model wat hulle ondersteun. Enige ander model-waarde, die Shannon-id's ingesluit, word met 400 beantwoord.

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

Vir 'n Shannon-model, lees die tokengetalle uit die usage-objek van 'n antwoord.

Hoe die telling gemaak word

Elke model word met sy eie tokenizer en sy eie klets-sjabloon getel. Geen skatting uit karakters of woorde word gebruik nie.

Wat getel word	Reël
'n Teks	Die tokens van die string soos gestuur. 'n Leë string tel 0.
Boodskappe	Die boodskappe en gereedskap word met die model se eie klets-sjabloon uitgelê, tot by die punt waar die antwoord begin, en daardie hele prompt word getel.
Rolle	`system`-, `user`-, `assistant`- en `tool`-boodskappe word getel. `developer` word as `system` getel. 'n Boodskap sonder inhoud en sonder gereedskapoproep voeg niks by nie.
Gereedskapoproepe en resultate	Gereedskapoproepe van vroeëre assistent-beurte en hul resultate is deel van die telling, op albei eindpunte.
Beelde	'n Beeld wat binne die liggaam gestuur word (base64 of 'n `data:`-URL) voeg een token per 28 × 28 piksel-blok by: `ceil(width / 28) × ceil(height / 28)`. 'n Beeld wat as 'n `http(s)`-URL gegee word, word nie deur hierdie eindpunte afgelaai nie en tel 1,024.

Voorbeeld: 'n beeld van 1,024 × 768 piksels tel ceil(1024 / 28) × ceil(768 / 28) = 37 × 28 = 1,036 tokens.

Die telling en wat 'n versoek gehef word

Die telling van 'n hele versoek word op dieselfde manier gemaak as die insettelling van 'n werklike versoek met dieselfde model, boodskappe en gereedskap. 'n Antwoord meld daardie getal as usage.prompt_tokens op Chat Completions, as usage.input_tokens op Responses, en as usage.input_tokens plus usage.cache_read_input_tokens op Messages.

Die telling is die inset voor die afslag vir gekasde inset. 'n Werklike versoek kan 'n deel van daardie inset uit die kas lees en daardie deel teen die gekasde tarief faktureer. Prompt-kassing
'n Beeld wat as 'n http(s)-URL gegee word, tel hier 1,024. 'n Werklike versoek laai die beeld af en tel dit volgens sy grootte in piksels, so die twee getalle kan verskil. Stuur die beeld as base64 om dieselfde getal te kry.
Uitset is nie deel van die telling nie. Die antwoord van 'n werklike versoek word bo-op as uitsettokens gefaktureer, redenering ingesluit.
'n text-telling het geen klets-formatering nie. Gebruik dit om 'n dokument of 'n prompt-deel te meet, en die messages-vorm om 'n versoek te meet.

Om 'n telling in 'n koste om te sit, vermenigvuldig dit met die model se insetprys per 1M tokens. Modelle en pryse

Perke

Perk	Waarde	Daarbo
Lengte van `text`	4,000,000 grepe (UTF-8)	`413` met die boodskap `text too long`
Versoekliggaam	32 MiB	`413`
Per versoek	Een teks of een gesprek	Stuur een versoek per teks om verskeie tekste te tel.

Tel-oproepe tel nie by die perk van 120 versoeke per minuut nie. Perke en balans

Foute

Status	Tipe	Boodskap	Wanneer
`400`	`invalid_request_error`	`tokenize is available for the hosted open models; unknown model: <model>`	`/v1/tokenize` met 'n `model` wat nie 'n gehuisveste oopgewig-id is nie.
`400`	`invalid_request_error`	`count_tokens is available for the hosted open models; unknown model: <model>`	`/v1/messages/count_tokens` met 'n `model` wat nie 'n gehuisveste oopgewig-id is nie, of sonder `model`.
`400`	`invalid_request_error`	send `text` or `messages`	`/v1/tokenize` met nóg `text` nóg `messages`.
`401`	`authentication_error`	`Missing authentication / Invalid API key`	Geen sleutel is gestuur nie, of die sleutel is nie geldig nie.
`413`	`invalid_request_error`	`text too long`	`text` is langer as 4,000,000 grepe. 'n Liggaam bo 32 MiB word ook met `413` beantwoord.
`415`	`invalid_request_error`	Expected request with `Content-Type: application/json`	Die versoek het geen JSON-inhoudtipe nie.
`422`	`invalid_request_error`	`Failed to deserialize the JSON body into the target type: …`	'n Vereiste veld ontbreek (`model` op `/v1/tokenize`, `messages` op `/v1/messages/count_tokens`) of 'n veld het die verkeerde tipe.
`503`	`api_error`	`token counting is temporarily unavailable for this model`	Die telling kan op die oomblik nie vir hierdie model gemaak word nie. Probeer later weer.

/v1/tokenize gee foute in die OpenAI-vorm terug. Op /v1/messages/count_tokens kom die foute van die eindpunt self (400 vir die model, 503) in die Anthropic-vorm, en 401, 413, 415 en 422 kom in die OpenAI-vorm. Lees eers die statuskode, dan error.type en error.message, wat in albei vorme teenwoordig is.

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