---
title: "Contar tokens antes de enviar: estimativas, margens, idiomas"
description: "Estime os tokens do prompt por idioma e modelo antes de chamar uma API de LLM: por que tokenizers diferem, exemplos em cinco idiomas e margens para max_tokens."
url: https://broadrouter.com/pt/blog/count-tokens-before-sending/
lang: pt-BR
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduzido do inglês com ajuda de IA. [Leia o original em inglês](https://broadrouter.com/blog/count-tokens-before-sending/) (atualizado em 2026-11-16).

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

Pela equipe da BroadNet Inference · 5 min de leitura · Publicado em 2026-11-14 · Atualizado em 2026-11-16

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.

## Pontos principais

-   Tokenizers variam de modelo para modelo. No nosso teste, a mesma frase em árabe deu 102 tokens com cl100k\_base, 46 com o200k\_base e de 48 a 58 nos tokenizers dos modelos abertos.
-   Neste teste curto, prosa em inglês rendeu cerca de 4,5 caracteres por token em todos os tokenizers; código, JSON e a maioria das escritas não latinas usam mais tokens por caractere.
-   Quando o tokenizer de um modelo não é público, calibre: envie amostras, leia usage.prompt\_tokens e guarde uma proporção por idioma e tipo de conteúdo.
-   A janela de contexto cobre prompt mais saída. Orce prompt + max\_tokens + uma margem, nunca só o prompt.
-   Em modelos de raciocínio, o pensamento conta em max\_tokens; a BroadNet recomenda pelo menos 1.000 ou reasoning\_effort low.

**Nesta página**

1.  Por que a contagem de tokens muda entre modelos?
2.  Como contar tokens com exatidão?
3.  Como estimar tokens quando o tokenizer não é público?
4.  Que margens usar para max\_tokens e contexto?
5.  O que dá errado nas estimativas de tokens?
6.  Onde a BroadNet Inference se encaixa

Você precisa de uma contagem de [tokens](https://broadrouter.com/pt/glossary/token/) antes de enviar uma requisição por três motivos: ficar dentro da [janela de contexto](https://broadrouter.com/pt/glossary/context-window/), escolher um [max\_tokens](https://broadrouter.com/pt/glossary/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](https://github.com/openai/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](https://broadrouter.com/tools/token-counter/) gratuito, ou nos contadores por família para [DeepSeek](https://broadrouter.com/tools/deepseek-token-counter/), [Qwen](https://broadrouter.com/tools/qwen-token-counter/) e [GPT](https://broadrouter.com/tools/gpt-token-counter/). Para ver quanto uma edição no prompt economiza, compare as duas versões no [diff de tokens do prompt](https://broadrouter.com/tools/prompt-token-diff/). Por que o árabe em especial custa mais tokens, medido em textos mais longos, está em [tokens por palavra em árabe e inglês](https://broadrouter.com/pt/blog/tokens-per-word-arabic-english/).

## Como contar tokens com exatidão?

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

```python
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:

```python
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](https://broadrouter.com/pt/models/gemma-4-vl-26b/) não valem para o [DeepSeek V4.1 Flash](https://broadrouter.com/pt/models/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](https://broadrouter.com/pt/glossary/reasoning-tokens/). 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](https://broadrouter.com/pt/models/glm-5.3/) | 1.048.576 | cerca de 897.000 |
| [Qwen3.8 27B](https://broadrouter.com/pt/models/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](https://broadrouter.com/tools/context-window-calculator/) 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](https://broadrouter.com/pt/blog/prompt-structure-for-caching/).

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](https://broadrouter.com/pt/blog/choosing-an-llm-for-arabic/). Para transformar contagens de tokens em uma fatura mensal, veja [como estimar o custo de uma API de LLM antes do lançamento](https://broadrouter.com/pt/blog/estimate-llm-api-cost-before-launch/).

## 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](https://broadrouter.com/pt/blog/million-token-context-window-guide/), e os preços por 1M de tokens estão na [página de preços](https://broadrouter.com/pt/pricing/).

Ferramentas gratuitas sobre o tema (em inglês)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Ferramentas gratuitas (em inglês)](https://broadrouter.com/tools/)

## Termos neste artigo

[Token](https://broadrouter.com/pt/glossary/token/)

Um token é a unidade de texto que um modelo de linguagem lê e escreve: uma palavra, parte de uma palavra, um sinal de pontuação ou uma sequência de bytes gerada pelo tokenizador do modelo. As APIs de LLM contam, limitam e normalmente cobram o uso em tokens.

[Tokenizer (tokenizador)](https://broadrouter.com/pt/glossary/tokenizer/)

Tokenizer (tokenizador) é o componente que converte texto na sequência de IDs inteiros de tokens que um modelo de linguagem lê, e converte os IDs gerados de volta em texto. Cada modelo vem com o próprio tokenizer, então o mesmo texto pode gerar um número diferente de tokens em modelos diferentes.

[Tool calling (chamada de ferramentas)](https://broadrouter.com/pt/glossary/tool-calling/)

Tool calling, também chamado de function calling ou chamada de ferramentas, é um recurso de APIs de LLM em que o modelo devolve um pedido estruturado para executar uma função definida pelo desenvolvedor, com argumentos JSON. A aplicação executa a função e devolve o resultado; o modelo nunca executa código sozinho.

[Janela de contexto (context window)](https://broadrouter.com/pt/glossary/context-window/)

A janela de contexto é o número máximo de tokens com que um modelo de linguagem consegue trabalhar em uma única requisição. Ela abrange o prompt, o histórico da conversa, as definições de ferramentas, as imagens e a saída gerada, incluindo os tokens de raciocínio. O que não couber precisa ser cortado, resumido ou dividido em várias requisições.

[max\_tokens](https://broadrouter.com/pt/glossary/max-tokens/)

max\_tokens é um parâmetro de APIs de LLM que define o máximo de tokens que um modelo pode gerar em uma resposta. Quando a geração atinge o limite, ela para e a resposta é marcada como cortada, por exemplo com finish\_reason igual a "length".

[Chat template (template de chat)](https://broadrouter.com/pt/glossary/chat-template/)

Chat template é a regra de formatação, geralmente escrita em Jinja e distribuída com o tokenizer do modelo, que converte uma lista de mensagens de chat com papéis na sequência única de tokens que o modelo espera, incluindo os tokens especiais de controle. Usar o template errado pode piorar muito as respostas do modelo.

[Tokens de entrada e de saída](https://broadrouter.com/pt/glossary/input-and-output-tokens/)

Tokens de entrada são os tokens que um modelo de linguagem lê em uma requisição, incluindo o system prompt, o histórico da conversa, as definições de ferramentas e as imagens. Tokens de saída são os que ele gera na resposta, incluindo o raciocínio. As APIs de LLM costumam cobrá-los separadamente, e a saída costuma custar mais.

[Prompt de sistema (system prompt)](https://broadrouter.com/pt/glossary/system-prompt/)

O system prompt, ou prompt de sistema, é o texto de instruções que uma aplicação envia a um modelo de linguagem antes da conversa, em geral como mensagem com o papel system ou developer. Ele define o papel, as regras, o tom e o formato de saída do modelo, que deve segui-lo mesmo quando mensagens do usuário o contradizem.

## 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.

## Continue lendo

-   [Tokens por palavra em árabe vs inglês: por que o árabe custa mais](https://broadrouter.com/pt/blog/tokens-per-word-arabic-english/)
-   [Quando vale a pena uma janela de contexto de 1M de tokens (ou não)](https://broadrouter.com/pt/blog/million-token-context-window-guide/)
-   [Como estimar o custo de API de LLM antes de lançar uma funcionalidade](https://broadrouter.com/pt/blog/estimate-llm-api-cost-before-launch/)
-   [Como estruturar prompts para o prefixo entrar em cache](https://broadrouter.com/pt/blog/prompt-structure-for-caching/)
-   [Reduzir tokens do prompt: cortes medidos em sistema, tools e dados](https://broadrouter.com/pt/blog/reduce-prompt-tokens/)
-   [Hardware de GPU e serving da BroadNet, segundo a própria BroadNet](https://broadrouter.com/pt/blog/broadnet-gpu-fleet-and-serving/)
-   [Cache de respostas de LLM para cortar custo: um cache exato em Python](https://broadrouter.com/pt/blog/cache-llm-responses-cut-cost/)
-   [Guia: Por que um modelo de raciocínio devolve uma resposta vazia](https://broadrouter.com/pt/guides/reasoning-tokens-empty-response/)
-   [Guia: Como usar o SDK Python da OpenAI com a BroadNet Inference](https://broadrouter.com/pt/guides/openai-python-sdk/)

Teste com a sua carga de trabalho real. Contas novas começam com US$ 5 de crédito para Gemma e transcrição. DeepSeek, GLM e Qwen3.8 exigem uma recarga.

[Começar](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-count-tokens-before-sending&utm_content=page-cta) ·

**Fontes**

-   [README do tiktoken: codificações e cerca de 4 bytes por token (consultado em 2026-11-14)](https://github.com/openai/tiktoken)
-   [Referência da API da BroadNet Inference: max\_tokens e raciocínio (consultada em 2026-11-14) (em inglês)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-count-tokens-before-sending&utm_content=sources)
-   [Preços e tamanhos de contexto da BroadNet Inference em formato legível por máquina (pricing.json, consultados em 2026-11-14) (em inglês)](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-count-tokens-before-sending&utm_content=sources)
-   [Hugging Face Transformers, documentação do tokenizer (consultada em 2026-11-14)](https://huggingface.co/docs/transformers/main_classes/tokenizer)
