---
title: "Como reduzir tokens do prompt: antes e depois, medidos"
description: "Economia de tokens medida com tokenizers reais ao enxugar prompt de sistema, few-shot, schemas de ferramentas, formatos de dados, histórico e diacríticos árabes."
url: https://broadrouter.com/pt/blog/reduce-prompt-tokens/
lang: pt-BR
updated: 2026-11-15
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/reduce-prompt-tokens/) (atualizado em 2026-11-16).

# Reduzir tokens do prompt: cortes medidos em sistema, tools e dados

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

Meça primeiro: registre prompt\_tokens por chamada, encontre a maior parte e compare antes e depois com o tokenizer do modelo. Em cinco tokenizers, enxugar um prompt de sistema prolixo economizou de 68 a 71%, e CSV usou de 31 a 41% menos tokens que JSON minificado. Em três modelos, um prompt de sistema enxuto com 3 ferramentas curtas em vez de 10 prolixas cortou cerca de 65 a 71% da requisição completa renderizada.

## Pontos principais

-   Conte com o tokenizer real e depois confirme com usage.prompt\_tokens. O chat template adiciona seus próprios tokens, e os schemas de ferramentas são reserializados por ele.
-   Ferramentas foram o maior custo fixo que medimos: 10 schemas de ferramentas prolixos adicionavam de 1.200 a 1.400 tokens a cada prompt renderizado. Envie só as ferramentas que o passo pode usar.
-   Dados tabulares: de JSON indentado para CSV economizou de 57 a 61%; de JSON minificado para CSV ainda economizou de 31 a 41%. Os tokenizers do Qwen e do Gemma quebram números em dígitos individuais, então dados cheios de números custam mais neles.
-   Trocar 16 turnos antigos por um resumo de 3 linhas reduziu um prompt do Qwen de 2.700 tokens para 1.100. Resumos perdem detalhes, então mantenha os últimos turnos literalmente.
-   Árabe totalmente vocalizado usou de 2,4 a 3,5 vezes os tokens do mesmo texto sem diacríticos. Remova-os, a menos que a tarefa precise deles.

**Nesta página**

1.  Como medimos?
2.  Quais cortes economizam mais tokens?
3.  Como fica uma requisição inteira?
4.  Como enxugar um prompt de sistema sem quebrá-lo?
5.  De quantos exemplos few-shot você precisa?
6.  Vale enviar ferramentas, dados e histórico de outro jeito?
7.  Onde entra o cache?
8.  Como medir o seu próprio prompt?
9.  Onde a BroadNet Inference se encaixa

Prompts mais curtos custam menos, deixam mais da [janela de contexto](https://broadrouter.com/pt/glossary/context-window/) para o trabalho de verdade e costumam devolver o primeiro token mais cedo. Mas “encurte o prompt” é um conselho vago. Este post mede cortes comuns num prompt realista de um bot de atendimento, com os tokenizers reais de quatro modelos abertos e com o `o200k_base` da OpenAI, para você ver quais edições valem o seu tempo.

Se você usa um agente de código, [o orçamento de tokens de um agente](https://broadrouter.com/pt/blog/agent-token-budget/) cobre esse loop. Este post é sobre prompts de aplicação: chatbots, classificadores e jobs de extração.

## Como medimos?

Todas as contagens abaixo são nossas, feitas em 15 de novembro de 2026:

-   **Tokenizers.** Os arquivos `tokenizer.json` oficiais do DeepSeek V4.1 Flash, GLM 5.3, Qwen3.8 27B e do Gemma 4 26B A4B do Google, cada um numa revisão fixa do Hugging Face (veja as Fontes), carregados com `tokenizers` 0.23.3 do Hugging Face. Mais o `o200k_base` do `tiktoken` 0.14.0, para comparar com os modelos GPT. Tokens especiais não foram adicionados.
-   **Prompts renderizados.** Para DeepSeek, GLM e Qwen, também renderizamos requisições completas com o `chat_template.jinja` publicado de cada modelo (sandbox do Jinja2), com prompt de sistema, ferramentas, histórico e pergunta, e contamos o resultado. Isso fica perto do que um servidor tokeniza, mas um provedor pode usar outro template, então a palavra final é o `usage.prompt_tokens` da API.
-   **Texto.** Um bot de atendimento sintético para uma operadora de telefonia fictícia: um prompt de sistema de 261 palavras, 10 ferramentas, 8 exemplos few-shot, 40 linhas de pedidos, um histórico de 20 turnos e um parágrafo em árabe de 31 palavras. Um prompt é um único dado. A sua economia vai ser diferente; o método continua valendo.

O Gemma 4 VL 26B da BroadNet é baseado no modelo do Google, então a contagem dele é uma estimativa. Os outros usam os arquivos dos próprios modelos.

## Quais cortes economizam mais tokens?

Texto cru, antes → depois, com a parcela economizada:

| Mudança | DeepSeek V4.1 Flash | GLM 5.3 | Qwen3.8 27B | Gemma 4 | GPT o200k |
| --- | --- | --- | --- | --- | --- |
| Prompt de sistema: 261 palavras → 66 palavras | 295 → 88 (70%) | 294 → 89 (70%) | 297 → 95 (68%) | 297 → 96 (68%) | 293 → 86 (71%) |
| Few-shot: 8 exemplos → 3 | 157 → 69 (56%) | 157 → 69 (56%) | 156 → 71 (54%) | 156 → 71 (54%) | 152 → 69 (55%) |
| 40 linhas: JSON indentado → JSON minificado | 2.446 → 1.606 (34%) | 2.460 → 1.581 (36%) | 3.180 → 1.980 (38%) | 3.210 → 2.010 (37%) | 2.446 → 1.567 (36%) |
| 40 linhas: JSON minificado → CSV | 1.606 → 948 (41%) | 1.581 → 960 (39%) | 1.980 → 1.359 (31%) | 2.010 → 1.382 (31%) | 1.567 → 946 (40%) |
| 10 ferramentas: descrições prolixas → curtas | 1.224 → 806 (34%) | 1.214 → 797 (34%) | 1.225 → 806 (34%) | 1.252 → 827 (34%) | 1.202 → 796 (34%) |
| 10 ferramentas prolixas → 3 curtas | 1.224 → 258 (79%) | 1.214 → 257 (79%) | 1.225 → 266 (78%) | 1.252 → 276 (78%) | 1.202 → 255 (79%) |
| Parágrafo em árabe: totalmente vocalizado → simples | 193 → 74 (62%) | 267 → 78 (71%) | 151 → 62 (59%) | 180 → 64 (64%) | 218 → 62 (72%) |

Para prosa em inglês, as porcentagens são parecidas entre os tokenizers, então um corte que ajuda num modelo ajuda nos outros. Duas linhas quebram esse padrão. Os dados de pedidos custaram ao Qwen e ao Gemma de 23 a 46% mais tokens que ao DeepSeek e ao GLM em todos os formatos, porque os tokenizers deles quebram números em dígitos individuais: `100200` são 6 tokens no Qwen e 2 no DeepSeek. E os diacríticos árabes pesam muito mais em alguns tokenizers que em outros.

## Como fica uma requisição inteira?

O texto cru não inclui o chat template. Renderizado pelo template de cada modelo, com a mesma pergunta do cliente, o prompt completo medido fica assim:

| Requisição | DeepSeek V4.1 Flash | GLM 5.3 | Qwen3.8 27B |
| --- | --- | --- | --- |
| A. Prompt de sistema prolixo + 10 ferramentas prolixas | 1.677 | 1.535 | 1.797 |
| B. Prompt de sistema enxuto + 10 ferramentas curtas | 1.052 | 913 | 1.176 |
| C. Prompt de sistema enxuto + 3 ferramentas curtas | 574 | 443 | 636 |
| D. Prompt de sistema enxuto, sem ferramentas | 136 | 121 | 174 |
| C + 20 turnos anteriores completos | 2.374 | 2.243 | 2.693 |
| C + resumo de 3 linhas + últimos 4 turnos | 979 | 849 | 1.103 |

Ir de A para C cortou cerca de 65 a 71% de cada requisição (64,6% no Qwen, 71,1% no GLM). A maior parte veio das ferramentas. Renderizadas com o prompt de sistema prolixo, as 10 ferramentas prolixas adicionavam 1.334 tokens no DeepSeek, 1.209 no GLM e 1.421 no Qwen; as 3 ferramentas curtas de C adicionavam de 322 a 462 em relação a D. Schemas de [chamada de ferramentas](https://broadrouter.com/pt/glossary/tool-calling/) vão em toda requisição, quer o modelo use as ferramentas ou não.

Em volume, isso soma. No [Qwen3.8 27B](https://broadrouter.com/pt/models/qwen3.8-27b/), ir de A para C economiza 1.161 tokens por requisição. Com 100.000 requisições por mês, são cerca de 116 milhões de tokens de entrada, ou 116 × $0.175 por mês pelo preço padrão de entrada.

## Como enxugar um prompt de sistema sem quebrá-lo?

Nosso prompt de 261 palavras e o de 66 palavras carregam as mesmas sete regras. Os cortes foram todos do mesmo tipo:

1.  **Corte a cortesia com o modelo.** “It is very important that you always remain polite and courteous at all times” (É muito importante que você seja sempre educado e cortês o tempo todo) virou nada: a linha do papel já implica isso.
2.  **Uma regra por linha.** Tópicos substituem frases do tipo “Please make sure that you always…” (Por favor, certifique-se de sempre…).
3.  **Junte duplicatas.** Três frases sobre idioma viraram “Reply in the customer’s language (Arabic or English), briefly.” (Responda no idioma do cliente, árabe ou inglês, de forma breve.)
4.  **Apague comportamentos padrão repetidos.** “Remember to always be helpful!” (Lembre-se de sempre ajudar!) não muda nada.

Depois, teste. Um prompt mais curto que perde uma regra custa mais do que economiza. Rode as duas versões nas mesmas 50 a 100 entradas reais e compare, como em [avaliar um LLM antes de trocar](https://broadrouter.com/pt/blog/evaluate-llm-before-switching/).

## De quantos exemplos few-shot você precisa?

Menos do que a maioria dos prompts carrega. Cada exemplo [few-shot](https://broadrouter.com/pt/glossary/few-shot-prompting/) é pago em toda chamada. Mantenha os que corrigem um erro que o modelo comete sem eles, como um exemplo em dialeto para um classificador de árabe, e tire os que ele já acerta. Nosso corte de 8 para 3 economizou de 54 a 56% do bloco de exemplos. Se 3 bastam para a sua tarefa é uma questão de acurácia, não de tokens, então confira no seu conjunto de teste.

## Vale enviar ferramentas, dados e histórico de outro jeito?

**Ferramentas.** Envie só as ferramentas que o passo atual pode usar. Uma pergunta sobre a fatura precisa de `get_account`, `get_bill` e `create_ticket`, não de `order_esim`. Encurte as descrições para o que o modelo precisa para escolher e preencher a ferramenta. A indentação não importa aqui: todos os templates que renderizamos reserializam o array `tools` com `tojson`, então um array de ferramentas formatado custa o mesmo que um minificado.

**Dados nas mensagens.** Os dados que você cola numa mensagem vão do jeito que estão. No mínimo, minifique o JSON. Para registros planos, CSV ou TSV eliminam as chaves repetidas: de 31 a 41% menos tokens que o JSON minificado no nosso teste. Dados aninhados continuam em JSON. Confira se o modelo ainda lê as colunas corretamente.

**Histórico.** Cada turno passado é reenviado. Trocar 16 turnos antigos por um resumo de três linhas, mantendo os últimos quatro turnos literalmente, reduziu o prompt do Qwen de 2.693 para 1.103 tokens. Um resumo perde detalhes que o usuário pode citar de novo, e reescrevê-lo muda o prefixo, o que quebra o cache. [Gerenciamento de contexto em agentes de longa duração](https://broadrouter.com/pt/blog/long-running-agent-context-management/) explica quando compactar.

**Diacríticos árabes.** A maior parte do árabe é escrita sem vogais curtas. Se a sua entrada é totalmente vocalizada, vinda de um dicionário, livro didático ou fonte religiosa, remover os sinais (de U+064B a U+0652) cortou nosso parágrafo de 59 a 72%. Mantenha-os quando a tarefa depende deles, como ensino ou poesia. [Normalização de texto em árabe](https://broadrouter.com/pt/blog/arabic-text-normalization-search/) cobre os outros caracteres que vale normalizar, e [tokens por palavra em árabe](https://broadrouter.com/pt/blog/tokens-per-word-arabic-english/) a diferença maior em relação ao inglês.

## Onde entra o cache?

O cache não encolhe o prompt. Ele barateia a parte repetida. O guia de caching da OpenAI diz que “the entire rendered prefix” (tradução: todo o prefixo renderizado) precisa coincidir e recomenda colocar as instruções estáveis primeiro. A [página de preços](https://inference.broadnet.ai/pricing?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-reduce-prompt-tokens&utm_content=body) da BroadNet descreve a entrada em cache como “usually the repeated start of recent requests, such as a long system prompt” (tradução: normalmente o início repetido de requisições recentes, como um prompt de sistema longo), sem nada a configurar, e a documentação dela informa os acertos em `usage.prompt_tokens_details.cached_tokens`.

Então a ordem é: encurte primeiro e depois torne estável o prefixo encurtado. Prompt de sistema e ferramentas primeiro, idênticos byte a byte em toda chamada; depois o histórico, só com acréscimos; a mensagem nova por último. No Qwen3.8 27B, a entrada em cache custa $0.0435 por 1M contra $0.175. [Estrutura de prompt para cache](https://broadrouter.com/pt/blog/prompt-structure-for-caching/) traz o layout e um teste que prova que o prefixo é reaproveitado. Tokens em cache continuam contando na janela de contexto.

## Como medir o seu próprio prompt?

Comece pela conta. Registre `usage.prompt_tokens` por ponto de chamada durante um dia e encontre o maior. Depois compare versões localmente com este script, que imprime as contagens antes e depois para dois arquivos:

```python
# pip install tokenizers tiktoken huggingface_hub
import json, sys
import tiktoken
from huggingface_hub import hf_hub_download
from tokenizers import Tokenizer

def hf(repo, rev):
    return Tokenizer.from_file(hf_hub_download(repo, "tokenizer.json", revision=rev))

COUNTERS = {
    "Qwen3.8 27B": hf("Qwen/Qwen3.8-27B", "37561816e66b5b9153b1b64c10968c18c1e6f4a0").encode,
    "GPT o200k": tiktoken.get_encoding("o200k_base").encode,
}

def n(enc, text):
    out = enc(text)
    return len(out.ids if hasattr(out, "ids") else out)

def diff(before, after):
    for name, enc in COUNTERS.items():
        a, b = n(enc, before), n(enc, after)
        print(f"{name:12} {a:6} -> {b:6}  saved {a - b} ({100 * (a - b) / a:.0f}%)")

if __name__ == "__main__":
    diff(open(sys.argv[1], encoding="utf-8").read(), open(sys.argv[2], encoding="utf-8").read())
```

Rodado nos nossos dois prompts de sistema, ele imprimiu:

```text
Qwen3.8 27B     297 ->     95  saved 202 (68%)
GPT o200k       293 ->     86  saved 207 (71%)
```

Adicione os repositórios dos outros modelos da lista de Fontes para comparar os quatro. Para uma checagem rápida no navegador, o [comparador de tokens de prompt](https://broadrouter.com/tools/prompt-token-diff/) compara duas versões lado a lado, e o [contador de tokens](https://broadrouter.com/tools/token-counter/) conta uma. Depois do deploy, confirme a economia em `usage.prompt_tokens`, que inclui o template.

## Onde a BroadNet Inference se encaixa

O BroadRouter é o site da BroadNet. A BroadNet Inference cobra os tokens do prompt pelo preço de entrada de cada modelo e lê prefixos repetidos do cache pelo preço de entrada em cache quando o modelo tem um, então tanto prompts mais curtos quanto prefixos estáveis baixam a conta. O [Gemma 4 VL 26B](https://broadrouter.com/pt/models/gemma-4-vl-26b/) tem contexto de 32.768 tokens, em que enxugar importa para caber, além do custo. Nos planos do DeepSeek V4.1 Flash não há medidor de tokens, mas o contexto de 1.048.576 tokens continua valendo, e um prompt mais curto continua respondendo mais cedo. Os prompts não são retidos depois de cada requisição.

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.

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

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

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

[Tokens de entrada em cache (cached input)](https://broadrouter.com/pt/glossary/cached-input-tokens/)

Tokens de entrada em cache são tokens do prompt que um provedor de LLM processou há pouco e pode reaproveitar de um cache em vez de calcular de novo, normalmente um prefixo repetido, como um system prompt ou um documento. Os provedores os cobram com uma tarifa menor que a dos tokens de entrada novos.

[Diacríticos árabes (tashkeel)](https://broadrouter.com/pt/glossary/arabic-diacritics/)

Diacríticos árabes, ou tashkeel, são pequenas marcas escritas acima ou abaixo das letras para indicar vogais curtas, consoantes dobradas e a ausência de vogal. São opcionais: a maior parte do texto árabe, incluindo notícias, não as usa, então leitores e software deduzem as vogais pelo contexto.

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

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

## Perguntas frequentes

### Como reduzir o número de tokens do meu prompt?

Meça primeiro: registre usage.prompt\_tokens e encontre a maior parte. Depois, na ordem do que mais economizou nas nossas medições: envie só as ferramentas que o passo precisa, encurte o texto das ferramentas e do prompt de sistema, envie tabelas em CSV e não em JSON, reduza os exemplos few-shot aos que mudam o resultado e resuma os turnos antigos do chat.

### JSON formatado com indentação usa mais tokens?

Sim. No nosso teste, minificar 40 linhas de JSON indentado economizou de 34 a 38% dos tokens, dependendo do tokenizer, e enviá-las em CSV economizou de 57 a 61%. Dito de outro jeito, o JSON indentado usou de 52 a 61% mais tokens que o minificado e de 132 a 159% mais que o CSV. Schemas de ferramentas são exceção: os chat templates os reserializam, então a indentação no seu array tools não chega ao modelo.

### Quantos tokens as definições de ferramentas usam?

Depende do texto e do template do modelo. Nossas 10 ferramentas com descrições prolixas adicionavam cerca de 1.200 a 1.400 tokens a um prompt renderizado no DeepSeek V4.1 Flash, no GLM 5.3 e no Qwen3.8 27B. Três ferramentas com descrições curtas adicionavam cerca de 320 a 460.

### Diacríticos árabes aumentam a contagem de tokens?

Muito. Um parágrafo em árabe padrão moderno de 31 palavras usou de 62 a 78 tokens sem diacríticos e de 151 a 267 tokens totalmente vocalizado, em cinco tokenizers. A maior parte do texto árabe é escrita sem eles, então remova-os da entrada, a menos que a tarefa, como poesia ou ensino, precise deles.

### Prompt caching é melhor que encurtar o prompt?

Os dois funcionam juntos. O cache barateia um prefixo repetido, mas ele continua contando na janela de contexto e continua tendo preço. Encurte primeiro e depois mantenha o prefixo encurtado idêntico byte a byte no início de cada requisição, para que ele possa ser lido do cache.

### Por que a minha contagem de tokens difere do prompt\_tokens da API?

A API conta o prompt renderizado: suas mensagens embrulhadas no chat template, mais os schemas de ferramentas no formato do template. Um tokenizer rodado no seu texto cru não vê isso. Use o tokenizer para comparar versões, e usage.prompt\_tokens para a conta.

## Continue lendo

-   [Orçamento de tokens de agentes: para onde vão os tokens de um loop](https://broadrouter.com/pt/blog/agent-token-budget/)
-   [Como contar tokens antes de enviar uma requisição a um LLM](https://broadrouter.com/pt/blog/count-tokens-before-sending/)
-   [Como estruturar prompts para o prefixo entrar em cache](https://broadrouter.com/pt/blog/prompt-structure-for-caching/)
-   [Tokens de entrada em cache: como reduzir a conta de API de LLM](https://broadrouter.com/pt/blog/cached-input-tokens-explained/)
-   [Tokens por palavra em árabe vs inglês: por que o árabe custa mais](https://broadrouter.com/pt/blog/tokens-per-word-arabic-english/)
-   [Gestão de contexto para agentes de longa duração com janela de 1M](https://broadrouter.com/pt/blog/long-running-agent-context-management/)
-   [10 formas de reduzir o custo de LLM de agentes de código, com economia](https://broadrouter.com/pt/blog/cut-coding-agent-llm-costs/)
-   [Cache de respostas de LLM para cortar custo: um cache exato em Python](https://broadrouter.com/pt/blog/cache-llm-responses-cut-cost/)
-   [Hardware de GPU e serving da BroadNet, segundo a própria BroadNet](https://broadrouter.com/pt/blog/broadnet-gpu-fleet-and-serving/)
-   [Revisão humana no seu fluxo de IA para documentos](https://broadrouter.com/pt/blog/document-review-queues/)
-   [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-reduce-prompt-tokens&utm_content=page-cta) ·

**Fontes**

-   [Qwen/Qwen3.8-27B no Hugging Face: tokenizer.json e chat\_template.jinja na revisão 37561816 (baixados em 2026-11-15)](https://huggingface.co/Qwen/Qwen3.8-27B)
-   [zai-org/GLM-5.3 no Hugging Face: tokenizer.json e chat\_template.jinja na revisão ba32f8c1 (baixados em 2026-11-15)](https://huggingface.co/zai-org/GLM-5.3)
-   [deepseek-ai/DeepSeek-V4.1-Flash no Hugging Face: tokenizer.json e chat\_template.jinja na revisão 314113f8 (baixados em 2026-11-15)](https://huggingface.co/deepseek-ai/DeepSeek-V4.1-Flash)
-   [google/gemma-4-26B-A4B-it no Hugging Face: tokenizer.json na revisão 4d7ae498, a base do Gemma 4 VL 26B da BroadNet (verificado em 2026-11-15)](https://huggingface.co/google/gemma-4-26B-A4B-it)
-   [tiktoken da OpenAI no GitHub: codificação o200k\_base, versão 0.14.0 usada (verificado em 2026-11-15)](https://github.com/openai/tiktoken)
-   [Guia de prompt caching da OpenAI: conteúdo estável primeiro, todo o prefixo renderizado precisa coincidir, ferramentas fazem parte do contexto em cache (verificado em 2026-11-15)](https://developers.openai.com/api/docs/guides/prompt-caching)
-   [Página de preços da BroadNet Inference: entrada em cache é o início repetido de requisições recentes, cobrado mais barato, nada a configurar (verificado em 2026-11-15) (em inglês)](https://inference.broadnet.ai/pricing?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-reduce-prompt-tokens&utm_content=sources)
-   [Referência da API da BroadNet Inference: tokens em cache informados no bloco usage, capacidades dos modelos (verificado em 2026-11-15) (em inglês)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-reduce-prompt-tokens&utm_content=sources)
