Teste de renderização

Teste de renderização em 2 minutos

Compare o HTML que o robô recebe com o que o navegador mostra. Três métodos, dois scripts testados e um critério de sucesso objetivo.

resposta curtaO teste de renderização compara o HTML inicial da página, que é o que muitos robôs recebem, com a página montada pelo navegador depois de executar JavaScript. Se o texto principal só existe na segunda versão, robôs que não executam JavaScript não o leem. O teste leva 2 minutos: abra o código-fonte (Ctrl+U), procure uma frase do conteúdo e confira se ela está lá.

Por que este teste importa

O navegador faz muito trabalho que o robô pode não fazer. Ele baixa o HTML, executa scripts, busca dados em APIs e monta a página que você vê. Um site pode parecer completo para o visitante e chegar quase vazio a um robô que lê só a primeira resposta do servidor.

A documentação do Google descreve o próprio processo em três fases: rastreamento, renderização e indexação. O Googlebot executa JavaScript com um Chromium sem interface e indexa o HTML renderizado. Mesmo assim, o Google recomenda renderização no servidor ou pré-renderização, porque deixa o site mais rápido para pessoas e para robôs e porque nem todo robô executa JavaScript.

Esse último ponto é o que pesa para IA. Em dezembro de 2024, a Vercel publicou a análise do tráfego de robôs na sua rede e no site nextjs.org: GPTBot, ClaudeBot e PerplexityBot buscavam arquivos JavaScript, mas não os executavam, enquanto o AppleBot renderizava a página como o Googlebot. É um dado de fornecedor, com amostra própria, de quase dois anos atrás. Nenhum fornecedor de IA garante o comportamento futuro dos seus robôs. Por isso o método correto é testar o seu site agora, não confiar em regra geral.

Critério de sucesso

A página passa quando o texto que responde à pergunta principal, o título principal (h1), os links de navegação e os dados de autoria estão no HTML inicial, sem depender de execução de JavaScript. Basta que uma frase central do conteúdo apareça na resposta crua do servidor.

Método 1: código-fonte (30 segundos)

  1. 01Abra a página no navegador e pressione Ctrl+U (Cmd+Option+U no Mac) para ver o código-fonte. Ele mostra a resposta do servidor, não a página montada.
  2. 02Use Ctrl+F e procure uma frase do primeiro parágrafo do conteúdo, de três a cinco palavras, sem acento.
  3. 03Se a frase aparece dentro das tags de texto (p, h1, li), o conteúdo está no HTML inicial. Se só aparece dentro de blocos de script em formato JSON, ou não aparece, o texto é montado pelo navegador.
  4. 04Confira também o título (title), o h1 e os links do menu. Links precisam ser elementos a com href no HTML.

Não confunda esse método com o painel Elements das ferramentas de desenvolvedor. O painel Elements mostra a página depois da execução de JavaScript, e é exatamente a versão que o teste procura distinguir.

Método 2: console do navegador (1 minuto)

Cole o código abaixo no console (F12, aba Console) da página que você quer testar. Troque a frase por um trecho do seu texto. Ele baixa o HTML inicial de novo e compara com o texto visível depois da renderização.

(async () => {
  const frase = 'cole aqui tres a cinco palavras do texto principal';
  const norm = (s) => s.normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase();
  const resposta = await fetch(location.href, { credentials: 'omit', headers: { Accept: 'text/html' } });
  const bruto = await resposta.text();
  const doc = new DOMParser().parseFromString(bruto, 'text/html');
  doc.querySelectorAll('script, style, noscript').forEach((n) => n.remove());
  const textoInicial = norm(doc.body ? doc.body.textContent.replace(/\s+/g, ' ') : '');
  const textoRenderizado = norm(document.body.innerText.replace(/\s+/g, ' '));
  console.table({
    'frase no HTML inicial': textoInicial.includes(norm(frase)),
    'frase na página renderizada': textoRenderizado.includes(norm(frase)),
    'caracteres de texto no HTML inicial': textoInicial.length,
    'caracteres de texto renderizado': textoRenderizado.length,
    'h1 no HTML inicial': doc.querySelectorAll('h1').length,
  });
})();

Como ler a tabela: se a frase está só na página renderizada e a diferença de caracteres é grande, o conteúdo depende de JavaScript. Se as duas colunas de texto são parecidas, o HTML inicial já traz o conteúdo.

Método 3: linha de comando com o user-agent de um robô

O terminal busca a página sem executar nada, que é o comportamento de um robô que não renderiza. A busca com curl funciona em Linux, Mac e no Git Bash do Windows. O parâmetro -A define o user-agent.

curl -sL -A "Mozilla/5.0 (compatible; OAI-SearchBot/1.0; +https://openai.com/searchbot)" \
  "https://www.seusite.com.br/pagina/" | grep -c -i "frase do texto principal"

O resultado é o número de linhas com a frase. Zero indica que a frase não está no HTML inicial. No PowerShell:

(Invoke-WebRequest -UseBasicParsing -Uri "https://www.seusite.com.br/pagina/").Content -match "frase do texto principal"

O resultado é True ou False. Para checar várias frases, o título, o h1, o canonical e a meta robots de uma vez, com três user-agents diferentes, use o script em Node (versão 18 ou superior):

// teste-render.mjs  |  uso: node teste-render.mjs https://seusite.com.br/pagina/ "frase um" "frase dois"
const [url, ...frases] = process.argv.slice(2);
if (!url || frases.length === 0) {
  console.error('Uso: node teste-render.mjs URL "frase 1" "frase 2"');
  process.exit(1);
}
const agentes = {
  'navegador comum': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0 Safari/537.36',
  'OAI-SearchBot': 'Mozilla/5.0 (compatible; OAI-SearchBot/1.0; +https://openai.com/searchbot)',
  'PerplexityBot': 'Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; PerplexityBot/1.0; +https://perplexity.ai/perplexitybot)'
};
const tira = (s) => s.normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase();
for (const [nome, ua] of Object.entries(agentes)) {
  const r = await fetch(url, { headers: { 'User-Agent': ua, Accept: 'text/html' }, redirect: 'follow' });
  const html = await r.text();
  const corpo = (html.match(/<body[\s\S]*<\/body>/i) || [html])[0];
  const semScripts = corpo.replace(/<script[\s\S]*?<\/script>/gi, ' ').replace(/<style[\s\S]*?<\/style>/gi, ' ');
  const texto = tira(semScripts.replace(/<[^>]+>/g, ' ').replace(/&nbsp;/g, ' ').replace(/\s+/g, ' '));
  console.log(`\n== ${nome} -> HTTP ${r.status}, ${html.length} bytes, texto visível: ${texto.length} caracteres`);
  console.log('   <title>:', (html.match(/<title[^>]*>([^<]*)<\/title>/i) || [])[1] || 'ausente');
  console.log('   <h1> no HTML inicial:', (html.match(/<h1[\s>]/gi) || []).length);
  console.log('   meta robots:', (html.match(/<meta[^>]+name=["']robots["'][^>]*>/i) || ['ausente'])[0]);
  console.log('   canonical:', (html.match(/<link[^>]+rel=["']canonical["'][^>]*>/i) || ['ausente'])[0]);
  for (const f of frases) console.log(`   frase "${f}":`, texto.includes(tira(f)) ? 'PRESENTE no HTML inicial' : 'AUSENTE do HTML inicial');
}

A versão em Python, sem bibliotecas externas:

# teste_render.py  |  uso: python teste_render.py URL "frase 1" "frase 2"
import re, sys, unicodedata, urllib.request

def sem_acento(s):
    return ''.join(c for c in unicodedata.normalize('NFD', s) if unicodedata.category(c) != 'Mn').lower()

url, frases = sys.argv[1], sys.argv[2:]
req = urllib.request.Request(url, headers={'User-Agent': 'Mozilla/5.0 (compatible; teste-render/1.0)', 'Accept': 'text/html'})
with urllib.request.urlopen(req, timeout=20) as r:
    status, html = r.status, r.read().decode('utf-8', 'replace')
m = re.search(r'<body[\s\S]*</body>', html, flags=re.I)
corpo = m.group(0) if m else html
limpo = re.sub(r'<(script|style)[\s\S]*?</\1>', ' ', corpo, flags=re.I)
texto = sem_acento(re.sub(r'\s+', ' ', re.sub(r'<[^>]+>', ' ', limpo)))
print(f'HTTP {status} | {len(html)} bytes | texto visível: {len(texto)} caracteres')
for f in frases:
    print(f'frase "{f}":', 'PRESENTE' if sem_acento(f) in texto else 'AUSENTE', 'no HTML inicial')

Os dois scripts foram executados em 14/10/2026 contra uma página pública simples e distinguiram corretamente uma frase presente de uma ausente. Eles mudam apenas o user-agent. Se o seu firewall bloqueia robôs por endereço IP, e não por nome, o teste local não reproduz o bloqueio: nesse caso, confira os logs do servidor ou da CDN, como descreve o checklist de citabilidade.

Exemplo preenchido (simulação)

Uma loja fictícia usa uma aplicação de página única. O código-fonte (Ctrl+U) mostra apenas uma div vazia e um script. A frase "frete grátis acima de" não aparece no HTML inicial, e o h1 conta zero. Já o painel Elements mostra o catálogo completo. Diagnóstico: o conteúdo é montado no navegador. A correção pedida à equipe de desenvolvimento é renderização no servidor ou geração estática para as páginas de produto e de categoria, preservando a interatividade depois do carregamento. Critério de aceite: o mesmo teste, repetido, encontra a frase e o h1 no HTML inicial.

Erros comuns

  • Testar só no navegador. O navegador executa tudo. Um site que "funciona perfeitamente" na tela pode chegar vazio ao robô.
  • Texto atrás de clique ou de rolagem. Abas, acordeões e conteúdo carregado ao rolar a página só existem no HTML inicial se estiverem no código. Texto buscado depois por uma chamada de API não está.
  • Links sem href. O Google descobre links apenas em elementos a com atributo href. Botões com evento de clique e rotas por fragmento (#/produtos) não são links para o robô.
  • noindex no HTML inicial, removido por script. Segundo a documentação do Google, ao encontrar noindex a página pode não ser renderizada, e retirar o noindex com JavaScript pode não funcionar.
  • Página de erro com status 200. Em aplicações de página única, a rota inexistente precisa devolver 404 ou conter noindex, para não virar um soft 404.

Como corrigir o que o teste encontrar

SituaçãoSoluçãoObservação
Conteúdo montado só no navegadorrenderização no servidor, geração estática ou pré-renderizaçãorecomendação do Google, que ajuda também o desempenho
Conteúdo vem de API após carregarincluir o dado no HTML da respostaa hidratação no navegador continua possível
Menu e links por JavaScriptgerar elementos a com href reaisrotas por fragmento viram caminhos reais
Robô bloqueado por firewallliberar por faixa de IP publicada pelo fornecedora Anthropic e a Perplexity publicam listas de IPs; a OpenAI descreve seus robôs na documentação

Próximo passo

Passou no teste? Siga para o teste de robots.txt e bots de IA, para garantir que os robôs certos podem entrar. Não passou? Leve o resultado à equipe de desenvolvimento com o método e o critério de aceite acima. Se o time precisa aprender a corrigir, o treinamento para desenvolvimento e TI cobre renderização, robôs e dados estruturados.

O Google executa JavaScript. Por que me preocupar?

Porque o Google é um dos robôs, não todos. A documentação dele mesmo recomenda renderização no servidor ou pré-renderização, pois nem todo robô executa JavaScript. E mesmo no Google a renderização acontece em uma fila, depois do rastreamento, o que pode atrasar a indexação de conteúdo montado no navegador.

Todos os robôs de IA ignoram JavaScript?

Não há garantia geral. Em dezembro de 2024 a Vercel observou que GPTBot, ClaudeBot e PerplexityBot não executavam JavaScript e que o AppleBot executava. Isso pode mudar. Teste o seu site periodicamente e confira a documentação atual de cada fornecedor.

Preciso reescrever o site para corrigir?

Nem sempre. Muitos frameworks oferecem renderização no servidor ou geração estática por configuração. O custo depende de como o projeto foi construído. O teste mostra o problema; o plano de correção pede uma avaliação técnica do projeto. Em muitos casos a mudança se resume a ligar um modo de geração do framework e a validar as páginas-chave.

O teste vale para sites WordPress?

Vale, mas a maioria dos temas de WordPress entrega o texto no HTML inicial. O problema aparece em construtores que carregam blocos por JavaScript, em plugins de abas e de carregamento tardio, e em temas headless. Rode o teste de qualquer forma em um modelo de cada tipo de página.

Fontes

  1. JavaScript SEO basics, Google Search Central (2026-03-04)
  2. The rise of the AI crawler, Vercel (2024-12-17)
  3. AI Features and Your Website, Google Search Central (2025-12-10)
  4. Overview of OpenAI crawlers, OpenAI (2026-10-14)
  5. Perplexity crawlers, Perplexity (2026-10-14)

Vamos olhar o seu caso?

Escolha a consultoria, a análise ou o projeto que combina com o seu momento. Cada serviço tem escopo, entregáveis e limites descritos antes da compra.