# Cada 301 custou 108 ms: conte os do seu site

Um comando curl mostra quantos 301 o navegador atravessa antes do primeiro byte, quanto cada salto custa e como colapsar a corrente inteira em um só desvio no .htaccess.

> um 301 custou 108 ms na nossa medição de laboratório (241,6 ms contra 133,9 ms na mesma página, mediana de 100 requisições); três saltos multiplicam esse custo, por estimativa linear. Conte os do seu site: `curl -sSL -o /dev/null -w '%{num_redirects}\n' http://seudominio.com.br`.

João Rizzon · 2026-09-28 · Infraestrutura web

---

## Por que um 301 custou 108 ms na bancada

Um redirecionamento parece barato porque a resposta é minúscula: cabeçalho, `Location`, corpo vazio. O que custa não é o conteúdo, é a viagem. O navegador precisa fazer uma requisição inteira, esperar a resposta, ler o `Location` e começar tudo de novo. Se o destino muda de esquema (http para https) ou de host (www para raiz), ainda entram DNS, TCP e handshake TLS de novo antes do segundo pedido.

Na nossa bancada, entrar pelo endereço com `www` (que responde um 301 para a raiz) custou **241,6 ms** de mediana até a mesma página, contra **133,9 ms** indo direto ao endereço canônico. São **108 ms** de diferença, em 100 requisições, em setembro de 2026.

Esse número sozinho não impressiona ninguém. Ele vira argumento quando você descobre que o site do cliente não faz um salto, faz três.

**+108 ms** custo mediano de chegar à mesma página entrando pelo endereço com www, que responde um 301 para a raiz: 241,6 ms no total contra 133,9 ms indo direto ao endereço canônico (n=100, setembro de 2026)

## A cadeia de três saltos que sobra de uma migração

A sequência típica de um site que já viveu um pouco:

- O visitante digita `dominio.com.br` e o navegador tenta `http://`.
- O servidor devolve 301 para `https://dominio.com.br`.
- Uma regra antiga, criada quando o site era `www`, devolve 301 para `https://www.dominio.com.br`.
- O WordPress, com `siteurl` sem `www`, devolve outro 301 de volta para `https://dominio.com.br`. (Se isso acontece, você tem loop, e o navegador acusa. O mais comum é a regra e o WP concordarem no host e a terceira etapa ser outra coisa: barra final, ou a URL antiga da página que mudou na migração.)
- Só então a página real começa a carregar.

Cada etapa dessas é uma ida e volta completa até o servidor. Estimando de forma linear a partir do nosso dado de 108 ms por salto:

| Saltos antes da página | Custo estimado só de desvio |
|---|---||
| 1 | ~108 ms |
| 2 | ~216 ms |
| 3 | ~324 ms |
| 4 | ~432 ms |

A estimativa é linear de propósito, e vale saber para que lado ela erra. O salto que medimos troca de host (`www` para a raiz), então os 108 ms já embutem DNS, TCP e TLS novos. Isso significa que a linha reta **superestima** saltos que ficam no mesmo host, como uma troca de caminho ou o acréscimo de barra final, que reaproveitam a conexão já aberta e custam menos. E **subestima** em rede pior: a nossa medição saiu de uma máquina com rota curta até o servidor, e em 4G ou em rota longa cada ida e volta pesa mais do que pesou aqui.

O ponto que interessa ao cliente: quatro saltos são quase meio segundo antes do primeiro byte do HTML. Antes do CSS. Antes de qualquer otimização de imagem que você vendeu.

## Como contar os saltos com curl

### O comando de uma linha que devolve o número de saltos

Para saber o número, e só o número:

```bash
curl -sSL -o /dev/null -w '%{num_redirects} saltos -> %{url_effective} em %{time_total}s\n' http://seudominio.com.br
```

- `-L` segue os redirecionamentos (sem ele, o curl para no primeiro 301 e `num_redirects` é 0).
- `-o /dev/null` joga fora o HTML.
- `num_redirects` é quantos desvios o curl seguiu até chegar ao destino.
- `url_effective` é onde ele parou de verdade.

Comece sempre por `http://` e sem `www`, que é o que a maioria das pessoas digita e o que muito link antigo aponta. É o caminho mais longo, e é ele que você precisa medir.

### O arquivo de formato que separa tempo de desvio de tempo de página

Salve como `curl-format.txt`:

```
    url_final:  %{url_effective}
     redirects: %{num_redirects}
 tempo_desvios: %{time_redirect}s
           dns: %{time_namelookup}s
           tcp: %{time_connect}s
           tls: %{time_appconnect}s
          ttfb: %{time_starttransfer}s
         total: %{time_total}s
```

E rode:

```bash
curl -sSL -o /dev/null -w '@curl-format.txt' http://seudominio.com.br
```

O campo que fecha o argumento é `time_redirect`: o curl reporta nele o tempo somado de todas as etapas de redirecionamento, incluindo DNS, conexão e transferência de cada uma, antes de a requisição final começar. Se `time_redirect` for 0,3 s e `time_total` 0,45 s, dois terços do que o cliente chama de "site lento" aconteceram antes de o site sequer entrar em cena.

### Ver cada Location da cadeia e descobrir onde mora cada regra

Para enxergar cada `Location` da corrente:

```bash
curl -sL -o /dev/null -D - http://seudominio.com.br | grep -iE '^(HTTP/|location:|server:)'
```

O `-D -` despeja os cabeçalhos de **todas** as respostas, inclusive as intermediárias. A saída fica assim:

```
HTTP/1.1 301 Moved Permanently
location: https://seudominio.com.br/
HTTP/2 301
location: https://www.seudominio.com.br/
HTTP/2 301
location: https://www.seudominio.com.br/home/
HTTP/2 200
```

Com isso você já sabe onde cada regra mora. O primeiro salto normalmente é `.htaccess` ou a camada de proxy. O salto que muda o host é `.htaccess` ou a configuração do WordPress. O salto que acrescenta barra ou troca o caminho costuma ser o `redirect_canonical` do WordPress ou um plugin de redirecionamento, e esse é o mais caro dos três em trabalho de servidor, porque acorda o PHP inteiro para responder um cabeçalho de 200 bytes.

Uma observação sobre `-I`: ele usa HEAD, e nem todo servidor ou plugin responde a HEAD igual ao GET. Para auditoria, prefira o GET com `-o /dev/null` como acima.

## As quatro portas de entrada que todo site precisa testar

Testar só a URL canônica não prova nada: ela é justamente a que não redireciona. Rode as quatro variantes e anote.

| Entrada | Comando | Saltos aceitáveis |
|---|---|---||
| `http://dominio.com.br` | `curl -sSL -o /dev/null -w '%{num_redirects}\n' http://dominio.com.br` | 1 |
| `http://www.dominio.com.br` | idem com `www` | 1 |
| `https://www.dominio.com.br` | idem | 1 (ou 0, se `www` for o canônico) |
| URL interna antiga (ex.: `/servicos-antigo/`) | idem | 1 |

A meta é **no máximo um 301 em qualquer porta de entrada**. Dois já é sintoma de regra empilhada. Três é migração que ninguém auditou.

Caso especial da barra final: se `https://dominio.com.br/contato` responde 301 para `/contato/`, some esse salto a tudo que veio antes. Em site WordPress isso é normal e resolvido pelo próprio WP, mas o ideal é que seus links internos, menu e sitemap já apontem para a forma com barra, para o visitante nunca pagar por ele.

## Colapsar a cadeia em um único 301

A regra é simples: **nenhuma regra deve redirecionar para uma URL que também redireciona**. Cada destino tem que ser o endereço final, com esquema certo, host certo e caminho certo.

### Regra única no .htaccess que acerta as quatro entradas

Para forçar HTTPS e retirar o `www` num só salto:

```apache
RewriteEngine On
RewriteCond %{HTTPS} !=on [OR]
RewriteCond %{HTTP_HOST} ^www\. [NC]
RewriteCond %{HTTP_HOST} ^(?:www\.)?(.+)$ [NC]
RewriteRule ^ https://%1%{REQUEST_URI} [R=301,L]
```

Leitura da lógica: se a conexão não é HTTPS **ou** o host começa com `www`, capture o domínio sem o prefixo e mande tudo, de uma vez, para `https://dominio` mantendo o caminho e a query string.

Se o canônico do cliente for **com** `www`, a estrutura é a mesma, só muda o destino:

```apache
RewriteEngine On
RewriteCond %{HTTPS} !=on [OR]
RewriteCond %{HTTP_HOST} !^www\. [NC]
RewriteCond %{HTTP_HOST} ^(?:www\.)?(.+)$ [NC]
RewriteRule ^ https://www.%1%{REQUEST_URI} [R=301,L]
```

A terceira linha é o detalhe que muita receita da internet esquece. A versão comum, `RewriteRule ^ https://www.%{HTTP_HOST}%{REQUEST_URI}`, quebra na entrada `http://www.dominio.com.br`: ali a condição `!^www\.` falha, o `[OR]` da linha do HTTPS salva o caso, a regra dispara e monta `https://www.www.dominio.com.br`. Capturando o host já sem o prefixo, o destino sai certo nas quatro entradas. Teste as quatro depois de mexer, sempre.

### Onde colocar a regra para o WordPress não apagá-la

Acima do bloco `# BEGIN WordPress`. O WordPress reescreve o próprio bloco quando você salva permalinks, e leva junto o que estiver dentro dele. O que está acima sobrevive.

### Alinhar siteurl e home com a regra do servidor

Com a regra do servidor resolvida, o WP não pode discordar. Em **Configurações > Geral**, `Endereço do WordPress` e `Endereço do site` precisam estar exatamente na forma canônica (com https, com ou sem www, sem barra no final). Pela WP-CLI:

```bash
wp option get siteurl
wp option get home
wp option update siteurl 'https://dominio.com.br'
wp option update home 'https://dominio.com.br'
```

Se os dois discordarem da regra do `.htaccess`, você criou um loop ou um salto extra. É a causa número um de cadeia de três saltos em site migrado.

### O entulho que a migração deixa em plugin de redirect, proxy e links internos

- **Plugin de redirect**: abra a lista e procure destinos que também redirecionam. Um `/servico-antigo/` apontando para `/servico/` que aponta para `/servicos/` vira dois saltos. Aponte o primeiro direto para o último.
- **Camada de proxy ou CDN**: as page rules e redirect rules do proxy rodam antes do servidor, e a combinação perigosa é SSL flexível. Se o proxy termina o TLS e fala **HTTP** com a origem, o `RewriteCond %{HTTPS} !=on` do `.htaccess` é verdadeiro em toda requisição: o servidor manda 301 para https, o proxy atende esse https e bate de novo na origem em HTTP, e você tem loop infinito, `ERR_TOO_MANY_REDIRECTS`, site fora do ar. Nesse cenário a condição correta é o cabeçalho que o proxy injeta:

```apache
RewriteCond %{HTTP:X-Forwarded-Proto} !https
```

Use essa linha no lugar de `%{HTTPS} !=on` sempre que houver proxy com origem em HTTP. Se a origem também fala HTTPS com o proxy (SSL full ou strict), mantenha `%{HTTPS} !=on`, mas escolha um único lugar para forçar HTTPS: se o "Always Use HTTPS" do proxy já resolve, desligue a condição no `.htaccess`, e vice-versa.

- **Links internos e menu**: depois de colapsar os saltos, busque no banco pelas URLs antigas. `wp search-replace 'http://www.dominio.com.br' 'https://dominio.com.br' --dry-run` mostra o tamanho do estrago antes de você aplicar.
- **Sitemap e canonical**: precisam apontar para a forma final. Sitemap listando URL que redireciona é rastreamento desperdiçado.
- **HSTS**: com o cabeçalho `Strict-Transport-Security` ativo, o navegador que já visitou o site pula o salto http→https sozinho nas próximas vezes. Não resolve a primeira visita nem o robô que chega frio, mas elimina o salto de quem volta. Só ligue quando o HTTPS estiver 100% estável, porque o navegador passa a recusar http por todo o período do `max-age`.

## Script para auditar a carteira inteira de uma vez

Se você mantém trinta sites, auditar um por um no navegador é perda de tempo. Um laço resolve.

```bash
#!/usr/bin/env bash
# uso: ./saltos.sh dominios.txt   (um dominio por linha, sem esquema)
while read -r d; do
  [ -z "$d" ] && continue
  curl -sSL -o /dev/null \
    -w "$d\t%{num_redirects} saltos\t%{time_redirect}s desvio\t%{time_total}s total\t%{url_effective}\n" \
    "http://$d"
done < "$1"
```

Rode uma vez, jogue a saída numa planilha e ordene por `num_redirects`. O que estiver com 2 ou mais entra na fila de correção. O que estiver com 1 está saudável.

Depois de corrigir cada site, o roteiro de validação é sempre o mesmo:

- Rodar as quatro entradas e confirmar 1 salto em cada.
- Testar uma URL interna profunda, não só a home.
- Testar com query string: `curl -sSL -o /dev/null -w '%{url_effective}\n' 'http://dominio.com.br/?utm_source=teste'` e conferir que os parâmetros sobreviveram ao redirecionamento.
- Limpar o cache de página (plugin e proxy) e repetir, porque cache de página pode servir um 301 antigo.
- Confirmar que não há loop: se `curl` reclamar de excesso de redirecionamentos, a regra do `.htaccess` está brigando com o `siteurl` ou com o SSL flexível do proxy.

Guarde o antes e o depois. `time_redirect` caindo de 0,32 s para 0,11 s num print é um entregável melhor que qualquer nota de ferramenta de performance.

## A explicação para mandar ao cliente sem jargão

Quando o cliente diz que "a home ficou meio segundo mais lenta depois da migração", ele está certo e o diagnóstico não é o servidor. Frase pronta, pode copiar:

> **** O site não ficou mais lento: ele ficou mais longe. Depois da migração, quem digita o endereço antigo passa por três desvios automáticos antes de chegar à página certa, e cada desvio é uma ida e volta completa até o servidor. Em medição de laboratório, um único desvio custou 108 ms. Unificando as regras em um só desvio, quem entra pelo endereço antigo passa a ver a página começar a carregar cerca de 200 ms mais cedo. Isso não muda o tempo de carregamento do restante do site, que tratamos à parte. Nada muda para quem já salvou o endereço novo nos favoritos, e nenhum link antigo deixa de funcionar.

Dois detalhes que evitam a pergunta seguinte. Primeiro: não se remove o redirecionamento, se colapsa. O link antigo continua funcionando, só chega em um passo em vez de três. Segundo: mantenha o 301 (permanente) e não o 302. O 301 é o que transfere autoridade para a URL nova e o que o navegador pode memorizar.

## O que colapsar a cadeia melhora e o que continua lento

Colapsar a cadeia melhora o tempo até o primeiro byte de quem entra por uma porta não canônica: visita que vem de link antigo, de material impresso, de e-mail antigo, de quem digita o domínio na barra. Não melhora nada para quem já entra na URL canônica, porque essa pessoa nunca pagou o custo.

Também não conserta banco lento, tema pesado nem imagem de 3 MB. Se `time_redirect` já está perto de zero e `time_starttransfer` continua alto, o problema é geração de página, e aí o caminho é outro: log de consulta lenta, cache de objeto, perfil de plugin.

A vantagem de medir com `curl -w` antes de mexer é exatamente essa: em dois minutos você sabe se está diante de um problema de cadeia de redirecionamento ou de um problema de aplicação, e para de vender a otimização errada.

---

## Como medimos

100 requisições HTTPS de um VPS externo à mesma página em um servidor LiteSpeed da Napoleon: 50 começando pelo endereço com www, que responde 301 para a raiz e obriga o cliente a abrir nova conexão e negociar TLS de novo no destino (curl -L, tempo total), e 50 indo direto à raiz. Medianas comparadas: 241,6 ms entrando pelo www, 133,9 ms indo direto.
