BroadRouter

Como contar tokens antes de enviar uma requisição a um LLM

Pela equipe da BroadNet Inference · 5 min de leitura · Publicado em · Atualizado em

Conte tokens com o tokenizer do modelo que você chama, quando ele é público; caso contrário, calibre uma proporção de caracteres por token a partir do campo usage de requisições reais, por idioma e tipo de conteúdo. Some uma margem de 10 a 20 por cento e verifique se tokens do prompt mais max_tokens cabem na janela de contexto, deixando espaço para tokens de raciocínio em modelos que pensam.

Você precisa de uma contagem de tokens antes de enviar uma requisição por três motivos: ficar dentro da janela de contexto, escolher um max_tokens sensato e estimar o custo. Contagens exatas só vêm do tokenizer do próprio modelo. Boas estimativas vêm de calibração. Este post mostra as duas coisas, com medições reais.

Por que a contagem de tokens muda entre modelos?

Um tokenizer divide o texto em pedaços de um vocabulário fixo. Cada família de modelos treina o seu. Um vocabulário maior, ou treinado com mais texto de um idioma, produz menos tokens nesse idioma. Então a pergunta “quantos tokens tem este prompt” tem uma resposta diferente para cada modelo.

Medimos a mesma mensagem curta de atendimento ao cliente, traduzida para quatro idiomas, mais uma pequena função Python e um objeto JSON de nota fiscal. As contagens da OpenAI vêm do tiktoken (cl100k_base, da época do GPT-4, e o200k_base, da época do GPT-4o). As contagens dos modelos abertos vêm dos arquivos de tokenizer que cada família publica no Hugging Face, contadas sem o chat template, em 14 de novembro de 2026.

Texto (mesmo significado) Caracteres cl100k_base o200k_base DeepSeek V4.1 Flash GLM 5.3 Qwen3.8 27B Gemma 4
Inglês, 31 palavras 173 37 37 37 38 39 39
Espanhol 160 47 40 50 45 43 42
Árabe 142 102 46 55 58 48 49
Chinês 54 51 37 34 35 36 38
Função Python 94 33 33 35 33 35 38
JSON de nota fiscal 140 59 60 63 60 72 72

Uma amostra por linha, então trate os números como ilustração, não como benchmark. Três lições valem mesmo assim. A geração do tokenizer importa: o texto em árabe caiu para menos da metade de cl100k_base para o200k_base. Os modelos abertos também diferem entre si: o mesmo texto em árabe variou de 48 a 58 tokens, e o JSON de 60 a 72. E conteúdo estruturado é denso em tokens em todo lugar: o JSON rendeu cerca de 2 caracteres por token em todos os tokenizers.

Você pode repetir o teste com o seu texto no contador de tokens gratuito, ou nos contadores por família para DeepSeek, Qwen e GPT. Para ver quanto uma edição no prompt economiza, compare as duas versões no diff de tokens do prompt. Por que o árabe em especial custa mais tokens, medido em textos mais longos, está em tokens por palavra em árabe e inglês.

Como contar tokens com exatidão?

Se o tokenizer do modelo é público, carregue-o e conte localmente. Para modelos da OpenAI:

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

Para famílias open-weight, o tokenizer costuma vir junto com o modelo no Hugging Face e carrega com AutoTokenizer.from_pretrained(...). Duas ressalvas: o chat template adiciona tokens para papéis e separadores, e a versão implantada por um provedor de API pode diferir dos arquivos públicos. A referência da API da BroadNet não documenta um endpoint de contagem de tokens nem o tokenizer de cada modelo, então o tokenizer público dá uma estimativa próxima e o número exato é usage.prompt_tokens depois da chamada.

Como estimar tokens quando o tokenizer não é público?

Calibre uma vez por modelo e depois estime localmente:

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

Use 20 ou mais amostras reais por tipo de conteúdo (seus prompts de verdade, não lorem ipsum). A requisição de base com uma palavra remove o overhead fixo do chat template, que estimate soma de volta como overhead; ajuste para a base que você mediu. Calibre no modelo mais barato da BroadNet só se for ele que você vai chamar: as proporções do Gemma 4 VL 26B não valem para o DeepSeek V4.1 Flash. Imagens também são cobradas como tokens de entrada, e imagens maiores usam mais, então calibre-as à parte por resolução.

Que margens usar para max_tokens e contexto?

A janela cobre prompt e saída. Em modelos de raciocínio, a saída inclui o pensamento oculto, informado como tokens de raciocínio. Faça o orçamento assim:

  1. Estimativa do prompt = contagem calibrada × 1,15 (uma margem de segurança de 15 por cento).
  2. Orçamento da resposta = a resposta mais longa que você aceita.
  3. Orçamento de raciocínio = para modelos que pensam, pelo menos 1.000 tokens; a documentação da BroadNet recomenda pelo menos 1.000 ou reasoning_effort: "low", porque um limite pequeno pode retornar uma resposta vazia.
  4. max_tokens = orçamento da resposta + orçamento de raciocínio.
  5. Verificação: estimativa do prompt + max_tokens ≤ janela de contexto. Se não couber, corte o prompt, não a resposta.

Janelas de contexto na BroadNet Inference, do arquivo de preços publicado:

Modelo Janela de contexto Teto prático do prompt com 16K de saída e margem de 15%
DeepSeek V4.1 Flash 1.048.576 cerca de 897.000
GLM 5.3 1.048.576 cerca de 897.000
Qwen3.8 27B 262.144 cerca de 213.000
Gemma 4 VL 26B 32.768 cerca de 14.000

A coluna do teto é (janela − 16.384) ÷ 1,15, arredondada para baixo. Troque 16.384 pelo seu max_tokens.

O que dá errado nas estimativas de tokens?

  • Contar palavras em vez de tokens. A regra de 0,75 palavra por token vale para inglês. Nossa amostra em árabe de 29 palavras deu de 46 a 102 tokens, conforme o tokenizer.
  • Esquecer ferramentas e prompt de sistema. Schemas de ferramentas são JSON, que é denso em tokens. Conte-os como parte do prompt.
  • Supor um truncamento silencioso. Algumas ferramentas descartam mensagens antigas sem avisar. A BroadNet diz que não corta o seu contexto, então confira o tamanho antes de enviar em vez de contar com o servidor para cortar. A calculadora de janela de contexto faz a verificação para você.
  • Ignorar o crescimento do histórico. Em um chat ou loop de agente, o prompt cresce a cada turno. Reconfira o orçamento a cada chamada, não uma vez por sessão. Um histórico estável também aproveita melhor o cache; veja estrutura de prompt para cache.

Se você trabalha em árabe, o tokenizer é mais um motivo para testar os modelos com o seu texto; o resto está em como escolher um LLM para árabe. Para transformar contagens de tokens em uma fatura mensal, veja como estimar o custo de uma API de LLM antes do lançamento.

Onde a BroadNet Inference se encaixa

A BroadNet Inference retorna em toda resposta prompt_tokens, completion_tokens e, quando o modelo informa, as contagens de tokens em cache e de raciocínio, que é tudo de que você precisa para calibrar. Ela não publica um endpoint de contagem nem tokenizers por modelo, então as contagens antes do envio são estimativas. O trabalho com contexto longo nos modelos de 1M de tokens está no guia da janela de contexto, e os preços por 1M de tokens estão na página de preços.

Perguntas frequentes

Quantos tokens tem uma palavra?

No conjunto de dados de tokenizers do BroadRouter, que reúne cinco tokenizers (os dos quatro modelos de chat da BroadNet e o o200k_base da OpenAI; a tabela de exemplo do post acrescenta o cl100k_base), 1.000 palavras em inglês dão cerca de 1,290 tokens, ou cerca de 1.29 tokens por palavra. A regra prática comum, 0,75 palavra por token, chega perto para prosa em inglês. Árabe, outras escritas não latinas e código usam mais tokens por palavra. Meça o seu próprio texto com o modelo que você chama.

Posso usar o tiktoken para contar tokens do DeepSeek, Qwen ou Gemma?

Só como estimativa aproximada. O tiktoken implementa as codificações da OpenAI. Outras famílias de modelos têm tokenizers próprios, muitas vezes no Hugging Face, e as contagens diferem. Calibre pelo campo usage.

Existe uma ferramenta gratuita para contar tokens do DeepSeek, Qwen, GLM ou Gemma?

Sim. O contador de tokens gratuito do BroadRouter roda no navegador os tokenizers publicados dessas famílias de modelos, então o texto não sai da sua máquina. Trate a contagem como uma estimativa do que a API vai informar, porque os chat templates adicionam alguns tokens.

O que acontece se o meu prompt for maior que a janela de contexto?

A maioria das APIs retorna um erro. Algumas ferramentas cortam mensagens antigas em silêncio. A BroadNet não corta o seu contexto, então confira prompt mais max_tokens contra a janela antes de enviar.

Quanta margem devo deixar para max_tokens?

Estime a resposta mais longa que você espera, some o orçamento de raciocínio para modelos que pensam e mantenha de 10 a 20 por cento da janela livre para erros de estimativa.

Ler em MarkdownPerguntar ao ChatGPTPerguntar ao ClaudePerguntar ao Perplexity