Token zählen

Zählen Sie die Tokens eines Textes oder einer ganzen Anfrage, bevor Sie sie senden.

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

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

Beide Endpunkte zählen mit dem Tokenizer des Modells, das Sie nennen, und es läuft kein Modell. Sie decken die gehosteten Open-Weight-Modelle ab. /v1/tokenize nimmt einen einfachen Text oder eine Chat-Completions-Konversation an. /v1/messages/count_tokens nimmt eine Anfrage im Anthropic-Messages-Format an, also den Aufruf, den das Anthropic SDK und Claude Code machen.

Das Zählen ist kostenlos. Ein Aufruf braucht Ihren API-Key, zieht nichts von Ihrem Guthaben ab und erscheint nicht in Ihrem Nutzungsprotokoll.

Einen Text zählen

Senden Sie model und text. Der Text wird so gezählt, wie er ist, ohne Chat-Formatierung darum herum.

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 Antwort

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

Die Zahlen in den Antworten auf dieser Seite sind Beispiele. Derselbe Text ergibt bei einem anderen Modell eine andere Zählung.

Eine Chat-Anfrage zählen

Senden Sie model und messages, mit tools, wenn die Anfrage welche hat, genau so, wie Sie sie an /v1/chat/completions senden würden. Die Antwort ist die Größe des gesamten Inputs.

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 Antwort

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

Felder von /v1/tokenize

Feld	Typ	Beschreibung
`model`	`string`	Erforderlich. Die ID eines gehosteten Open-Weight-Modells. Groß- und Kleinschreibung werden gleich behandelt.
`text`	`string`	Ein Text, der so gezählt wird, wie er ist, ohne Chat-Formatierung. Bis zu 4,000,000 Bytes. Senden Sie `text` oder `messages`; sind beide vorhanden, wird `text` gezählt.
`messages`	`array`	Chat-Nachrichten im Format der Chat Completions. Sie werden als vollständiger Input einer Anfrage gezählt: jede Nachricht mit der Formatierung, die das Chat-Template des Modells um sie legt.
`tools`	`array`	Tool-Definitionen, die in die Zählung einbezogen werden. Wird zusammen mit `messages` verwendet.

Die Antwort ist ein JSON-Objekt mit diesen Feldern:

Feld	Typ	Beschreibung
`model`	`string`	Die Modell-ID, für die gezählt wurde, in ihrer veröffentlichten Schreibweise.
`tokens`	`integer`	Mit `text`: die Tokens des Textes. Mit `messages`: die Tokens des gesamten Inputs, Bilder eingeschlossen.

Eine Messages-Anfrage zählen

Senden Sie den Body, den Sie an /v1/messages senden würden: model, messages sowie system und tools, wenn Sie sie verwenden. Die offiziellen Anthropic-SDKs rufen diesen Endpunkt über messages.count_tokens auf.

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 Antwort

{
  "input_tokens": 21
}

Felder von /v1/messages/count_tokens

Feld	Typ	Beschreibung
`model`	`string`	Erforderlich. Die ID eines gehosteten Open-Weight-Modells.
`messages`	`array`	Erforderlich. Nachrichten im Anthropic-Messages-Format. Blöcke vom Typ `text`, `image`, `tool_use` und `tool_result` werden gezählt.
`system`	`string \| array`	Der System-Prompt: ein String oder ein Array von Textblöcken.
`tools`	`array`	Tool-Definitionen mit `name`, `description` und `input_schema`.

Aus Kompatibilitätsgründen akzeptiert, ohne Auswirkung auf die Zählung: tool_choice, max_tokens, temperature, top_p, stop_sequences, stream, thinking. Sie können den Body einer echten Anfrage unverändert übergeben.

Die Antwort ist ein JSON-Objekt mit diesen Feldern:

Feld	Typ	Beschreibung
`input_tokens`	`integer`	Die Tokens des gesamten Inputs: System-Prompt, Nachrichten, Tools und Bilder.

Unterstützte Modelle

Beide Endpunkte zählen für die gehosteten Open-Weight-Modelle. GET /v1/models führt /v1/tokenize und /v1/messages/count_tokens in den endpoints jedes Modells auf, das sie unterstützt. Jeder andere model-Wert, die Shannon-IDs eingeschlossen, wird mit 400 beantwortet.

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

Bei einem Shannon-Modell lesen Sie die Token-Anzahlen aus dem Objekt usage einer Antwort ab.

Wie gezählt wird

Jedes Modell wird mit seinem eigenen Tokenizer und seinem eigenen Chat-Template gezählt. Es wird keine Schätzung anhand von Zeichen oder Wörtern verwendet.

Was gezählt wird	Regel
Ein Text	Die Tokens des Strings, wie er gesendet wurde. Ein leerer String zählt 0.
Nachrichten	Die Nachrichten und Tools werden mit dem eigenen Chat-Template des Modells bis zu dem Punkt angeordnet, an dem die Antwort beginnt, und dieser gesamte Prompt wird gezählt.
Rollen	Nachrichten mit `system`, `user`, `assistant` und `tool` werden gezählt. `developer` wird als `system` gezählt. Eine Nachricht ohne Inhalt und ohne Tool-Aufruf fügt nichts hinzu.
Tool-Aufrufe und Ergebnisse	Tool-Aufrufe früherer Assistant-Turns und deren Ergebnisse sind bei beiden Endpunkten Teil der Zählung.
Bilder	Ein Bild, das im Body gesendet wird (Base64 oder eine `data:`-URL), fügt einen Token pro Patch von 28 × 28 Pixeln hinzu: `ceil(width / 28) × ceil(height / 28)`. Ein Bild, das als `http(s)`-URL angegeben ist, wird von diesen Endpunkten nicht heruntergeladen und zählt 1,024.

Beispiel: Ein Bild von 1,024 × 768 Pixeln zählt ceil(1024 / 28) × ceil(768 / 28) = 37 × 28 = 1,036 Tokens.

Die Zählung und was einer Anfrage berechnet wird

Die Zählung einer ganzen Anfrage erfolgt auf dieselbe Weise wie die Input-Zählung einer echten Anfrage mit demselben Modell, denselben Nachrichten und Tools. Eine Antwort meldet diese Zahl als usage.prompt_tokens bei Chat Completions, als usage.input_tokens bei Responses und als usage.input_tokens plus usage.cache_read_input_tokens bei Messages.

Die Zählung ist der Input vor dem Rabatt für Cached Input. Eine echte Anfrage kann einen Teil dieses Inputs aus dem Cache lesen und diesen Teil zum Cached-Preis berechnen. Prompt-Caching
Ein Bild, das als http(s)-URL angegeben ist, zählt hier 1,024. Eine echte Anfrage lädt das Bild herunter und zählt es nach seiner Größe in Pixeln, sodass die beiden Zahlen abweichen können. Senden Sie das Bild als Base64, um dieselbe Zahl zu erhalten.
Output ist nicht Teil der Zählung. Die Antwort einer echten Anfrage wird zusätzlich als Output-Tokens berechnet, Reasoning eingeschlossen.
Eine Zählung von text enthält keine Chat-Formatierung. Verwenden Sie sie, um ein Dokument oder einen Teil eines Prompts zu messen, und die Form mit messages, um eine Anfrage zu messen.

Um eine Zählung in Kosten umzurechnen, multiplizieren Sie sie mit dem Input-Preis des Modells pro 1M Tokens. Modelle & Preise

Limits

Limit	Wert	Darüber
Länge von `text`	4,000,000 Bytes (UTF-8)	`413` mit der Nachricht `text too long`
Request-Body	32 MiB	`413`
Pro Anfrage	Ein Text oder eine Konversation	Senden Sie pro Text eine Anfrage, um mehrere Texte zu zählen.

Zähl-Aufrufe zählen nicht zum Limit von 120 Anfragen pro Minute. Limits und Guthaben

Fehler

Status	Typ	Nachricht	Wann
`400`	`invalid_request_error`	`tokenize is available for the hosted open models; unknown model: <model>`	`/v1/tokenize` mit einem `model`, das keine ID eines gehosteten Open-Weight-Modells ist.
`400`	`invalid_request_error`	`count_tokens is available for the hosted open models; unknown model: <model>`	`/v1/messages/count_tokens` mit einem `model`, das keine ID eines gehosteten Open-Weight-Modells ist, oder ohne `model`.
`400`	`invalid_request_error`	send `text` or `messages`	`/v1/tokenize` weder mit `text` noch mit `messages`.
`401`	`authentication_error`	`Missing authentication / Invalid API key`	Es wurde kein Key gesendet, oder der Key ist nicht gültig.
`413`	`invalid_request_error`	`text too long`	`text` ist länger als 4,000,000 Bytes. Ein Body über 32 MiB wird ebenfalls mit `413` beantwortet.
`415`	`invalid_request_error`	Expected request with `Content-Type: application/json`	Die Anfrage hat keinen JSON-Content-Type.
`422`	`invalid_request_error`	`Failed to deserialize the JSON body into the target type: …`	Ein erforderliches Feld fehlt (`model` bei `/v1/tokenize`, `messages` bei `/v1/messages/count_tokens`), oder ein Feld hat den falschen Typ.
`503`	`api_error`	`token counting is temporarily unavailable for this model`	Die Zählung kann für dieses Modell im Moment nicht durchgeführt werden. Versuchen Sie es später erneut.

/v1/tokenize gibt Fehler in der OpenAI-Form zurück. Bei /v1/messages/count_tokens kommen die Fehler des Endpunkts selbst (400 für das Modell, 503) in der Anthropic-Form, und 401, 413, 415 und 422 kommen in der OpenAI-Form. Lesen Sie zuerst den Statuscode, dann error.type und error.message, die in beiden Formen vorhanden sind.

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