BroadRouter

Tokens zählen, bevor Sie eine LLM-Anfrage senden

Vom Team von BroadNet Inference · 5 Min. Lesezeit · Veröffentlicht · Aktualisiert

Zählen Sie Tokens mit dem Tokenizer des Modells, das Sie aufrufen, sofern er öffentlich ist. Andernfalls kalibrieren Sie ein Verhältnis Zeichen pro Token aus dem usage-Feld echter Anfragen, getrennt nach Sprache und Inhaltstyp. Rechnen Sie 10 bis 20 Prozent Puffer hinzu und prüfen Sie, ob Prompt-Tokens plus max_tokens ins Kontextfenster passen, mit Platz für Reasoning-Tokens bei Thinking-Modellen.

Sie brauchen die Token-Zahl vor dem Senden einer Anfrage aus drei Gründen: um im Kontextfenster zu bleiben, um ein sinnvolles max_tokens zu wählen und um die Kosten zu schätzen. Exakte Zahlen liefert nur der Tokenizer des Modells selbst. Gute Schätzungen liefert eine Kalibrierung. Dieser Beitrag zeigt beides, mit echten Messwerten.

Warum unterscheiden sich Token-Zahlen zwischen Modellen?

Ein Tokenizer zerlegt Text in Stücke aus einem festen Vokabular. Jede Modellfamilie trainiert ihr eigenes. Ein größeres Vokabular, oder eines, das mit mehr Text einer bestimmten Sprache trainiert wurde, erzeugt für diese Sprache weniger Tokens. Die Frage „Wie viele Tokens hat dieser Prompt?“ hat also für jedes Modell eine andere Antwort.

Wir haben dieselbe kurze Kundenservice-Nachricht gemessen, übersetzt in vier Sprachen, dazu eine kleine Python-Funktion und ein Rechnungsobjekt in JSON. Die OpenAI-Zahlen stammen von tiktoken (cl100k_base aus der GPT-4-Ära und o200k_base aus der GPT-4o-Ära). Die Zahlen der offenen Modelle stammen aus den Tokenizer-Dateien, die jede Familie auf Hugging Face veröffentlicht, gezählt ohne Chat-Template, am 14. November 2026.

Text (gleiche Bedeutung) Zeichen cl100k_base o200k_base DeepSeek V4.1 Flash GLM 5.3 Qwen3.8 27B Gemma 4
Englisch, 31 Wörter 173 37 37 37 38 39 39
Spanisch 160 47 40 50 45 43 42
Arabisch 142 102 46 55 58 48 49
Chinesisch 54 51 37 34 35 36 38
Python-Funktion 94 33 33 35 33 35 38
Rechnungs-JSON 140 59 60 63 60 72 72

Eine Stichprobe pro Zeile: Verstehen Sie die Zahlen als Illustration, nicht als Benchmark. Drei Lehren gelten trotzdem. Die Tokenizer-Generation zählt: Der arabische Text schrumpfte von cl100k_base zu o200k_base auf weniger als die Hälfte. Auch offene Modelle unterscheiden sich untereinander: Derselbe arabische Text lag zwischen 48 und 58 Tokens, das JSON zwischen 60 und 72. Und strukturierte Inhalte sind überall token-dicht: Das JSON kam bei jedem Tokenizer auf etwa 2 Zeichen pro Token.

Mit dem kostenlosen Token-Zähler können Sie das mit Ihrem eigenen Text wiederholen, ebenso mit den Zählern für DeepSeek, Qwen und GPT. Was eine Änderung am Prompt einspart, sehen Sie, wenn Sie beide Versionen im Prompt-Token-Diff vergleichen. Warum gerade Arabisch mehr Tokens kostet, gemessen an längeren Texten, behandelt der Beitrag Tokens pro Wort: Arabisch vs. Englisch.

Wie zählen Sie Tokens exakt?

Ist der Tokenizer des Modells öffentlich, laden Sie ihn und zählen lokal. Für OpenAI-Modelle:

import tiktoken
enc = tiktoken.encoding_for_model("gpt-4o")
n = len(enc.encode(text))

Bei Open-Weight-Familien liegt der Tokenizer meist zusammen mit dem Modell auf Hugging Face und lässt sich mit AutoTokenizer.from_pretrained(...) laden. Zwei Einschränkungen: Das Chat-Template fügt Tokens für Rollen und Trennzeichen hinzu, und die bei einem API-Anbieter bereitgestellte Version kann von den öffentlichen Dateien abweichen. Die API-Referenz von BroadNet dokumentiert weder einen Endpoint zum Zählen von Tokens noch den Tokenizer je Modell. Der öffentliche Tokenizer liefert also eine gute Schätzung, und die exakte Zahl ist usage.prompt_tokens nach dem Aufruf.

Wie schätzen Sie Tokens, wenn der Tokenizer nicht öffentlich ist?

Kalibrieren Sie einmal pro Modell und schätzen Sie danach lokal:

import os
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])

def prompt_tokens(model, text):
    r = client.chat.completions.create(
        model=model, max_tokens=1000,  # room for reasoning on thinking models
        messages=[{"role": "user", "content": text}],
    )
    return r.usage.prompt_tokens

def measure(model, samples: dict[str, list[str]]):
    base = prompt_tokens(model, "hi")  # chat-template overhead plus one short word
    ratios = {}
    for kind, texts in samples.items():
        chars = toks = 0
        for t in texts:
            chars += len(t)
            toks += prompt_tokens(model, t) - base
        ratios[kind] = chars / toks
    return ratios  # e.g. {"english": 4.1, "arabic": 2.9, "json": 2.3}

def estimate(text, kind, ratios, overhead=10):
    return int(len(text) / ratios[kind]) + overhead

Nehmen Sie 20 oder mehr echte Beispiele pro Inhaltstyp (Ihre tatsächlichen Prompts, kein Lorem ipsum). Die Basisanfrage mit einem einzigen Wort entfernt den festen Overhead des Chat-Templates, den estimate als overhead wieder hinzurechnet; setzen Sie ihn auf Ihre gemessene Basis. Kalibrieren Sie nur dann mit dem günstigsten Modell von BroadNet, wenn Sie genau dieses aufrufen werden: Verhältnisse von Gemma 4 VL 26B lassen sich nicht auf DeepSeek V4.1 Flash übertragen. Bilder werden ebenfalls als Input-Tokens abgerechnet, und größere Bilder verbrauchen mehr. Kalibrieren Sie sie daher separat nach Auflösung.

Welche Puffer sollten Sie für max_tokens und Kontext einplanen?

Das Fenster umfasst Prompt und Ausgabe. Bei Reasoning-Modellen enthält die Ausgabe das verborgene Thinking, ausgewiesen als Reasoning-Tokens. Planen Sie so:

  1. Prompt-Schätzung = kalibrierte Zahl × 1,15 (15 Prozent Sicherheitspuffer).
  2. Antwort-Budget = die längste Antwort, die Sie akzeptieren.
  3. Reasoning-Budget = bei Thinking-Modellen mindestens 1.000 Tokens; die Doku von BroadNet empfiehlt mindestens 1.000 oder reasoning_effort: "low", weil ein zu kleines Limit eine leere Antwort liefern kann.
  4. max_tokens = Antwort-Budget + Reasoning-Budget.
  5. Prüfung: Prompt-Schätzung + max_tokens ≤ Kontextfenster. Wenn nicht, kürzen Sie den Prompt, nicht die Antwort.

Kontextfenster bei BroadNet Inference, laut veröffentlichter Preisdatei:

Modell Kontextfenster Praktische Prompt-Obergrenze bei 16K Ausgabe und 15 % Puffer
DeepSeek V4.1 Flash 1.048.576 etwa 897.000
GLM 5.3 1.048.576 etwa 897.000
Qwen3.8 27B 262.144 etwa 213.000
Gemma 4 VL 26B 32.768 etwa 14.000

Die Spalte mit der Obergrenze ist (Fenster − 16.384) ÷ 1,15, abgerundet. Ersetzen Sie 16.384 durch Ihr eigenes max_tokens.

Was geht bei Token-Schätzungen schief?

  • Wörter statt Tokens zählen. Die Regel von 0,75 Wörtern pro Token gilt für Englisch. Unser arabisches Beispiel mit 29 Wörtern ergab je nach Tokenizer 46 bis 102 Tokens.
  • Tools und System-Prompt vergessen. Tool-Schemas sind JSON, und JSON ist token-dicht. Zählen Sie sie zum Prompt.
  • Stilles Abschneiden voraussetzen. Manche Tools verwerfen alte Nachrichten, ohne Bescheid zu geben. BroadNet gibt an, Ihren Kontext nicht zu kürzen. Prüfen Sie die Größe also vor dem Senden, statt sich darauf zu verlassen, dass der Server kürzt. Der Kontextfenster-Rechner übernimmt die Prüfung für Sie.
  • Wachsenden Verlauf ignorieren. In einem Chat oder einer Agent-Schleife wächst der Prompt mit jedem Zug. Prüfen Sie das Budget bei jedem Aufruf neu, nicht einmal pro Session. Ein stabiler Verlauf wird außerdem besser gecacht; siehe Prompt-Struktur für Caching.

Wenn Sie auf Arabisch arbeiten, ist der Tokenizer ein weiterer Grund, Modelle mit Ihrem eigenen Text zu testen; ein LLM für Arabisch auswählen behandelt den Rest. Wie Sie aus Token-Zahlen eine Monatsrechnung machen, zeigt LLM-API-Kosten vor dem Launch schätzen.

Wo BroadNet Inference ins Bild passt

BroadNet Inference gibt in jeder Antwort prompt_tokens, completion_tokens und, wenn das Modell sie meldet, die Zahl der gecachten und der Reasoning-Tokens zurück. Mehr brauchen Sie zum Kalibrieren nicht. Einen Endpoint zum Zählen oder Tokenizer je Modell veröffentlicht BroadNet nicht, Zahlen vor dem Senden sind also Schätzungen. Arbeit mit langem Kontext auf den Modellen mit 1M Tokens behandelt der Leitfaden zum Kontextfenster, und die Preise pro 1M Tokens stehen auf der Preisseite.

Häufige Fragen

Wie viele Tokens hat ein Wort?

Im Tokenizer-Datensatz von BroadRouter, der fünf Tokenizer zusammenfasst (die der vier Chat-Modelle von BroadNet und o200k_base von OpenAI; die Beispieltabelle im Beitrag ergänzt cl100k_base), entsprechen 1.000 englische Wörter etwa 1,290 Tokens, also etwa 1.29 Tokens pro Wort. Die gängige Faustregel von 0,75 Wörtern pro Token passt für englischen Fließtext recht gut. Arabisch, andere nicht-lateinische Schriften und Code brauchen mehr Tokens pro Wort. Messen Sie Ihren eigenen Text mit dem Modell, das Sie aufrufen.

Kann ich mit tiktoken Tokens für DeepSeek, Qwen oder Gemma zählen?

Nur als grobe Schätzung. tiktoken implementiert die Encodings von OpenAI. Andere Modellfamilien liefern eigene Tokenizer, oft auf Hugging Face, und die Zahlen weichen ab. Kalibrieren Sie gegen das usage-Feld.

Gibt es ein kostenloses Tool, um Tokens für DeepSeek, Qwen, GLM oder Gemma zu zählen?

Ja. Der kostenlose Token-Zähler von BroadRouter führt die veröffentlichten Tokenizer dieser Modellfamilien in Ihrem Browser aus, sodass der Text Ihren Rechner nicht verlässt. Betrachten Sie das Ergebnis als Schätzung dessen, was die API melden wird, denn Chat-Templates fügen einige Tokens hinzu.

Was passiert, wenn mein Prompt länger ist als das Kontextfenster?

Die meisten APIs geben einen Fehler zurück. Manche Tools kürzen alte Nachrichten stillschweigend. BroadNet kürzt Ihren Kontext nicht, prüfen Sie also Prompt plus max_tokens vor dem Senden gegen das Fenster.

Wie viel Puffer sollte ich für max_tokens lassen?

Schätzen Sie die längste Antwort, die Sie erwarten, addieren Sie bei Thinking-Modellen das Reasoning-Budget und halten Sie 10 bis 20 Prozent des Fensters für Schätzfehler frei.

Als Markdown lesenChatGPT fragenClaude fragenPerplexity fragen