Comptage de jetons pour GPT, Claude et Llama dans une seule API

Vous envoyez une invite à GPT-4o et la réponse est interrompue au milieu de la phrase. Vous vérifiez votre facture et trouvez un travail par lots a coûté 40 $ car l'entrée était 3 fois plus grande que ce à quoi vous vous attendiez. Tu colles longtemps documentez dans Claude et obtenez une erreur : fenêtre de contexte dépassée. Chacun de ces problèmes trace retour à la même cause profonde ; vous ne saviez pas combien de jetons contenait votre texte avant de l'envoyer.

Le comptage de jetons est la vérification préalable au vol dont chaque intégration LLM a besoin. Le nombre de personnages ne vous aidera pas. Le nombre de mots vous met dans une position approximative, mais les tokeniseurs divisent le texte différemment selon le modèle. Vous avez besoin du nombre exact pour le modèle que vous appelez.

Pourquoi le nombre de caractères n'est pas le nombre de jetons

Les LLM ne traitent pas les caractères bruts. Ils divisent le texte en jetons à l'aide d'un tokenizer, qui est un vocabulaire de morceaux de sous-mots formés sur un large corpus. Le mappage du texte aux jetons est non évident et spécifique au modèle.

Quelques exemples qui montrent pourquoi compter les caractères vous induit en erreur :

• "Je ne peux pas" se divise en 3 jetons dans GPT-4 : I, can, 't. Cela fait 7 caractères mais 3 jetons.
• "l'anti-désestablishmentarisme" est un mot mais 6 à 8 jetons selon le modèle. Le tokenizer le divise en sous-mots qu’il reconnaît.
• "Bonjour" est 1 jeton. " Bonjour" (avec des espaces de début) pourrait être 2 jetons car l'espace obtient son propre jeton.
• Extraits de code symboliser différemment de la prose. Accolades, points-virgules et l'indentation consomme chacune des jetons. Une fonction de 500 caractères peut facilement coûter plus de 200 jetons.

Les modèles GPT utilisent le BPE (encodage par paire d'octets) avec le vocabulaire cl100k_base ou o200k_base. Claude utilise un tokenizer BPE similaire mais distinct. Llama utilise SentencePièce. Le même paragraphe produit des le jeton compte dans les trois.

Compter les jetons avec un seul appel API

Envoyez votre texte au botoi /v1/token/count point final avec le modèle cible. L'API renvoie le nombre estimé de jetons ainsi que le nombre de caractères et de mots.

curl -X POST https://api.botoi.com/v1/token/count \\
  -H "Content-Type: application/json" \\
  -d '{
    "text": "The quick brown fox jumps over the lazy dog. This sentence is used to test tokenizers across different language models.",
    "model": "gpt-4o"
  }'

Réponse:

{
  "success": true,
  "data": {
    "tokens": 24,
    "model": "gpt-4o",
    "method": "estimated",
    "characters": 116,
    "words": 20
  }
}

La réponse vous indique que cette phrase de 20 mots coûte 24 jetons en GPT-4o. Vous obtenez également characters et words pour une référence rapide. Le method champ indique l’approche de comptage utilisée.

Nombre de jetons par modèle

Le même texte produit un nombre de jetons différent selon le modèle que vous ciblez. Le model Le paramètre accepte 15 modèles dans les grandes familles. Voici comment ils se comparent pour la même entrée :

Modèle	Tokeniseur	Fenêtre contextuelle	Jetons (même texte)
gpt-4o	o200k_base (BPE)	128 Ko	24
gpt-3.5-turbo	cl100k_base (BPE)	16K	24
claude-3.5-sonnet	Claude BPE	200K	25
fermer-4-travail	Claude BPE	200K	25
lama-3.2	PhrasePièce	128 Ko	24
gemini-2.0-flash	PhrasePièce	1M	24
mistral	Morceau de phrase (BPE)	32K	24

Les différences sont faibles pour les phrases courtes en anglais, mais augmentent à mesure que la longueur d'entrée augmente. Non anglais le texte, le code et les données structurées (JSON, XML) peuvent présenter des variations plus importantes. Comptez toujours les jetons avec le modèle spécifique que vous envisagez d'appeler.

Tronquer le texte à une limite de jetons

Lorsque votre invite dépasse la fenêtre contextuelle, vous devez la couper sans rompre le milieu du mot. Le /v1/token/truncate le point de terminaison coupe le texte à un nombre de jetons cible au niveau d'une limite de mot.

curl -X POST https://api.botoi.com/v1/token/truncate \\
  -H "Content-Type: application/json" \\
  -d '{
    "text": "You are a helpful assistant. Summarize the following document in three bullet points. The document discusses the impact of renewable energy adoption on global carbon emissions over the past decade, with specific focus on solar and wind installations in Europe and Southeast Asia.",
    "max_tokens": 20,
    "model": "claude-3.5-sonnet"
  }'

Réponse:

{
  "success": true,
  "data": {
    "truncated": "You are a helpful assistant. Summarize the following document in three bullet points. The",
    "tokens": 18,
    "was_truncated": true,
    "model": "claude-3.5-sonnet",
    "max_tokens": 20,
    "original_tokens": 48
  }
}

L'invite d'origine était de 48 jetons. L'API l'a tronqué à 18 jetons (dans le cadre du budget de 20 jetons) à une limite de mot propre. Le was_truncated flag vous indique si le texte a été modifié. Le original_tokens Le champ indique le nombre de jetons contenus dans le texte intégral.

Ceci est utile pour adapter les invites du système à des budgets de jetons serrés, en réduisant l'historique des discussions pour qu'il reste dans la fenêtre contextuelle et fragmenter les documents avant de les envoyer à une API d'intégration.

Créer une vérification avant vol pour les appels LLM

L'intégration la plus rentable : une fonction qui compte les jetons et les compare au contexte du modèle fenêtre et tronque si l'invite est trop longue. Cela évite à la fois la troncature silencieuse et les erreurs d'API.

const MODEL_LIMITS = {
  "gpt-4o": 128000,
  "gpt-4o-mini": 128000,
  "claude-3.5-sonnet": 200000,
  "claude-4-sonnet": 200000,
  "llama-3.2": 128000,
};

async function countTokens(text, model = "gpt-4o") {
  const res = await fetch("https://api.botoi.com/v1/token/count", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ text, model }),
  });
  const { data } = await res.json();
  return data.tokens;
}

async function truncateText(text, maxTokens, model = "gpt-4o") {
  const res = await fetch("https://api.botoi.com/v1/token/truncate", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ text, max_tokens: maxTokens, model }),
  });
  const { data } = await res.json();
  return data;
}

async function preflightCheck(prompt, model = "gpt-4o") {
  const limit = MODEL_LIMITS[model];
  if (!limit) throw new Error("Unknown model: " + model);

  const tokens = await countTokens(prompt, model);

  // Reserve 20% of the context window for the model's response
  const inputBudget = Math.floor(limit * 0.8);

  if (tokens <= inputBudget) {
    return { safe: true, tokens, limit, model };
  }

  // Truncate to fit within the input budget
  const result = await truncateText(prompt, inputBudget, model);

  return {
    safe: false,
    original_tokens: tokens,
    truncated_tokens: result.tokens,
    truncated_text: result.truncated,
    limit,
    model,
  };
}

// Usage
const prompt = buildPromptFromChatHistory(messages);
const check = await preflightCheck(prompt, "claude-3.5-sonnet");

if (!check.safe) {
  console.log(
    "Prompt truncated from " +
    check.original_tokens + " to " +
    check.truncated_tokens + " tokens"
  );
  prompt = check.truncated_text;
}

const response = await callLLM(prompt, "claude-3.5-sonnet");

La fonction réserve 20 % de la fenêtre contextuelle pour la réponse du modèle. Si l'entrée correspond, elle passe sans changement. S'il est trop important, il est tronqué dans le budget d'entrée. Tu as toujours sachez exactement combien de jetons vous envoyez.

Enroulez ceci autour de chaque appel LLM dans votre candidature. Il ajoute une requête HTTP (deux si la troncature est nécessaire) et élimine toute une classe d’échecs de production.

Cas d'utilisation réels

• Estimation des coûts avant les appels API. Comptez les jetons dans un lot d'invites, multipliez par le prix par jeton du modèle et connaissez le coût total avant de vous engager. Cette fonction Node.js le fait en quelques lignes :

async function estimateCost(text, model = "gpt-4o") {
  const tokens = await countTokens(text, model);

  // Price per 1M input tokens (March 2026 pricing)
  const rates = {
    "gpt-4o": 2.50,
    "gpt-4o-mini": 0.15,
    "claude-3.5-sonnet": 3.00,
    "claude-4-sonnet": 4.00,
    "llama-3.2": 0.00,  // self-hosted
  };

  const rate = rates[model] || 0;
  const cost = (tokens / 1_000_000) * rate;

  return {
    tokens,
    model,
    estimated_cost_usd: cost.toFixed(6),
  };
}

// Check cost before sending a large document
const estimate = await estimateCost(longDocument, "gpt-4o");
console.log(estimate);
// { tokens: 14320, model: "gpt-4o", estimated_cost_usd: "0.035800" }

• Validation rapide de la taille. Rejetez ou supprimez les invites soumises par les utilisateurs qui dépassent votre budget symbolique de l'application. Empêchez une seule entrée longue de consommer la totalité de votre limite de débit.
• Regrouper les documents pour les intégrations. Divisez les documents longs en morceaux adaptés dans la limite de jetons de votre modèle d’intégration (généralement 512 ou 8 192 jetons). Compter les jetons par morceau pour garantir qu’aucun ne dépasse la limite.
• Gestion de l'historique des discussions. À mesure que les conversations se développent, les messages plus anciens augmentent le total nombre de jetons au-delà de la fenêtre contextuelle. Comptez le total cumulé des jetons après chaque message et supprimez les messages les plus anciens lorsque vous approchez de la limite.
• Protections de pipeline CI/CD. Ajoutez une étape de comptage de jetons à votre pipeline de déploiement. Si un modèle d'invite dépasse un seuil défini, la construction échoue avant qu'elle n'atteigne la production.

Points clés

• Le nombre de jetons varie selon le modèle. GPT, Claude et Llama symbolisent le même texte différemment. Spécifiez toujours le modèle cible lors du comptage.
• Deux points de terminaison couvrent l’intégralité du flux de travail. /v1/token/count te dit la taille. /v1/token/truncate garnitures pour s’adapter. Les deux prennent en charge 15 modèles.
• Les contrôles avant vol évitent les échecs de production. Compter les jetons avant chaque LLM appelez pour éviter les réponses tronquées, les erreurs de fenêtre contextuelle et les coûts surprises.
• Aucun compte requis. Le niveau gratuit autorise 5 requêtes par minute sans inscription. Obtenez une clé API pour un volume plus élevé sur botoi.com/api.

La documentation complète sur l'API couvrent la liste complète des modèles pris en charge et des points de terminaison supplémentaires des utilitaires de développement.