# Corrente de redirecionamentos no site: como cortar para um só

Migração, troca de domínio e HTTPS deixam regras empilhadas em camadas diferentes. Veja como identificar quem responde cada 301 e trocar a corrente por um salto só.

> um único 301 com troca de host já custou 108 ms na nossa medição (241,6 ms contra 133,9 ms indo direto). Para arrumar, leia o cabeçalho Location de cada salto com curl, descubra qual camada emite cada 301 e troque tudo por uma regra que vai direto ao endereço final.

João Rizzon · 2026-11-10 · Infraestrutura web

---

## Por que a corrente aparece depois de uma migração

Quase nenhuma corrente de redirecionamentos é projetada. Ela se acumula. Cada pessoa que mexeu no site resolveu um problema na camada que tinha à mão, e ninguém olhou o conjunto.

O roteiro típico de um site que trocou de domínio ou de hospedagem tem três saltos:

- `http://www.dominio-antigo.com.br` responde 301 para `https://www.dominio-antigo.com.br` (regra de HTTPS no servidor ou no CDN).
- `https://www.dominio-antigo.com.br` responde 301 para `https://www.dominio-novo.com.br` (regra de troca de domínio no `.htaccess` ou num plugin).
- `https://www.dominio-novo.com.br` responde 301 para `https://dominio-novo.com.br` (o WordPress corrigindo o host porque `home` e `siteurl` estão sem www).

Cada regra, isolada, está certa. O problema é a ordem: o visitante passa por todas, uma depois da outra, antes de receber o HTML. Quem decide se o site deve ter www ou não já decidiu. Aqui o trabalho é outro: fazer qualquer endereço antigo chegar ao endereço final em **um** salto.

**+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)

## Como ler cada salto da corrente com curl

O `curl` mostra cada resposta da corrente se você pedir só os cabeçalhos e mandar seguir os redirecionamentos. Filtre as três linhas que importam: o status, o destino e quem respondeu.

```bash
curl -sIL http://www.dominio-antigo.com.br/contato/ | grep -iE '^(HTTP|location|server|x-redirect-by)'
```

A saída vem em blocos, um por salto. Algo assim:

```text
HTTP/1.1 301 Moved Permanently
Server: cloudflare
Location: https://www.dominio-antigo.com.br/contato/
HTTP/2 301
server: cloudflare
location: https://www.dominio-novo.com.br/contato/
HTTP/2 301
server: cloudflare
x-redirect-by: WordPress
location: https://dominio-novo.com.br/contato/
HTTP/2 200
server: cloudflare
```

Leia de cima para baixo. Cada `Location` é a URL que o próximo bloco respondeu. O último bloco com `200` é o destino real.

Repare que todos os blocos mostram `server: cloudflare`: os dois domínios estão atrás do CDN, então o `Server` não separa CDN de origem. Quem desempata é o `x-redirect-by` (o terceiro bloco veio do WordPress) e um teste direto na origem, pulando o CDN: `curl -sIL --resolve www.dominio-antigo.com.br:443:IP_DA_ORIGEM https://www.dominio-antigo.com.br/contato/`. Se a origem não devolver o 301 do segundo bloco, ele nasceu no CDN. Se a corrente terminar em `404`, o caminho se perdeu em algum salto (é comum a regra antiga mandar tudo para a home ou descartar o caminho).

Teste sempre com um caminho interno, não só com a raiz. Muita regra funciona para `/` e quebra para `/contato/` ou para URLs com parâmetro.

## Como descobrir qual camada emitiu cada 301

O cabeçalho `Location` diz para onde vai. Os outros cabeçalhos do mesmo bloco dizem quem mandou. Não existe um campo oficial de "origem do redirecionamento", então você cruza sinais.

| Sinal no bloco do 301 | Camada provável | Onde desligar ou ajustar |
|---|---|---||
| `Server: cloudflare` e nenhum cabeçalho do seu servidor | Regra no CDN (Always Use HTTPS, Redirect Rules, Page Rules) | Painel do CDN |
| `X-Redirect-By: WordPress` | Núcleo do WordPress corrigindo host ou barra final | `home` e `siteurl` em Configurações > Geral ou no `wp-config.php` |
| `X-Redirect-By` com nome de plugin (ex.: Yoast SEO, redirection) | Plugin de redirecionamento ou SEO | Lista de redirecionamentos do plugin |
| `Server: Apache` sem `X-Redirect-By` | `.htaccess` ou VirtualHost | Regras `RewriteRule` com `R=301` |
| `Server: nginx` sem `X-Redirect-By` | Bloco `server` com `return 301` | Configuração do nginx ou painel da hospedagem |
| Painel de hospedagem com opção "forçar HTTPS" ativa | Regra gerada pelo painel, geralmente no servidor web | Desativar a opção se você centralizar em outro lugar |

Dois cuidados. Primeiro: se o site está atrás de CDN, o `Server` pode aparecer como o do CDN mesmo quando quem gerou o 301 foi a origem. Nesse caso o `X-Redirect-By` ou cabeçalhos próprios da origem desempatam. Segundo: o PHP só roda se a requisição chegar ao WordPress, então um 301 com `X-Redirect-By: WordPress` prova que as camadas anteriores deixaram passar.

## Como reduzir a corrente a um único 301

A regra é simples de enunciar: **a primeira camada que recebe a requisição deve mandar direto para a URL final**, com esquema, host e caminho corretos de uma vez. As camadas seguintes não devem ter mais nada a corrigir.

### Em que camada fazer a regra única

Se o domínio passa pelo CDN, faça tudo lá ou tudo no servidor. Misturar é o que cria a corrente. Na prática, para agência que mantém muitos sites em hospedagens diferentes, o `.htaccess` é o lugar mais portátil: vai junto com o backup e não depende de painel de terceiros.

### Regra única no .htaccess ou no nginx para esquema e host

No Apache, coloque antes do bloco do WordPress no `.htaccess`:

```apache
RewriteEngine On
RewriteCond %{HTTP_HOST} ^(www\.)?dominio-antigo\.com\.br$ [NC,OR]
RewriteCond %{HTTP_HOST} ^www\.dominio-novo\.com\.br$ [NC,OR]
RewriteCond %{HTTPS} off
RewriteRule ^ https://dominio-novo.com.br%{REQUEST_URI} [L,R=301]
```

Qualquer combinação (domínio antigo com ou sem www, novo com www, qualquer um em HTTP) cai numa única resposta que já aponta para o endereço final, preservando o caminho. Para o domínio antigo funcionar aqui, ele precisa apontar no DNS para o mesmo servidor e ter certificado válido, senão o visitante que digita `https://dominio-antigo...` vê erro de certificado antes de qualquer 301.

Atenção se o site está atrás de CDN ou de proxy reverso na hospedagem. Com Cloudflare em SSL Flexible, o CDN fala com a origem em HTTP, `%{HTTPS}` fica sempre `off` e a regra manda para https em loop infinito. Duas saídas: colocar o CDN em Full (strict), com certificado válido na origem, ou trocar a condição por `RewriteCond %{HTTP:X-Forwarded-Proto} !https`. Use essa segunda só se o proxy sempre envia o cabeçalho: sem proxy ele não existe, a condição fica sempre verdadeira e o loop volta. Depois de aplicar, rode `curl -sSIL` na URL: loop aparece como a mesma `Location` repetida até o curl parar com `Maximum (50) redirects followed`.

No nginx, o equivalente é um bloco `server` para os hosts que não são canônicos:

```nginx
server {
    listen 80;
    listen 443 ssl;
    server_name dominio-antigo.com.br www.dominio-antigo.com.br www.dominio-novo.com.br;
    # ssl_certificate e ssl_certificate_key aqui
    return 301 https://dominio-novo.com.br$request_uri;
}

# HTTP do host canônico: sem este bloco, http://dominio-novo.com.br
# cai no default_server da porta 80, que pode não redirecionar
server {
    listen 80;
    server_name dominio-novo.com.br;
    return 301 https://dominio-novo.com.br$request_uri;
}
```

### O que desligar depois da regra única

Depois da regra única, remova as duplicatas: opção "forçar HTTPS" do painel, Always Use HTTPS do CDN se o servidor já cuida, redirecionamentos de domínio inteiro dentro de plugin. Plugin de redirecionamento continua útil para URLs que mudaram de caminho (uma página antiga que virou outra), não para troca de host.

Confira também se `home` e `siteurl` no WordPress estão exatamente no endereço final. Se estiverem com www e o servidor manda para sem www, o WordPress devolve para o www e você cria um loop.

### Como validar cada entrada depois da correção

Rode o mesmo `curl` de antes para cada variação de entrada. O resultado esperado é um bloco `301` com `Location` no endereço final e, logo depois, um `200`. Teste em aba anônima também: navegador guarda 301 em cache e pode mascarar a correção.

## Quanto custa um salto, e o que não sabemos

Medimos o caso mais simples: entrar pelo endereço com www que responde 301 para a raiz, contra ir direto ao endereço canônico. Foram 100 requisições em setembro de 2026. A mediana foi 241,6 ms pelo www e 133,9 ms direto, ou seja, **108 ms a mais por um único 301**. Não detalhamos aqui ferramenta, ponto de origem, servidor, presença de CDN nem se a conexão era nova a cada requisição, então trate o número como ordem de grandeza, não como constante. Para reproduzir no seu caso, compare o `%{time_total}` do `curl -w` nas duas entradas, com conexão nova a cada chamada.

A explicação provável, que não medimos, é que a troca de host obriga a abrir nova conexão e negociar TLS de novo. Nem sempre vale: navegadores com HTTP/2 podem reaproveitar a conexão (coalescência) quando os dois hosts resolvem para o mesmo IP e estão no mesmo certificado.

Esse número não deve ser multiplicado por três. O custo de cada salto depende de o host mudar ou não (mudou, provavelmente há nova negociação TLS, salvo coalescência de HTTP/2; não mudou, a conexão pode ser reaproveitada), da distância até o servidor e de o salto ser respondido pelo CDN ou pela origem. Não medimos uma corrente de três saltos, então não afirmamos quanto ela custa. O que a medição mostra é que um único salto com troca de host já pesa na ordem de uma centena de milissegundos, e uma corrente herdada de migração costuma trocar de host mais de uma vez.

Além do tempo, cada salto é mais um ponto para errar: certificado expirado no domínio antigo, regra que descarta o caminho, CDN com cache de um redirecionamento velho.

## Como aplicar a correção em vários sites de uma vez

Para padronizar na carteira de clientes, monte um arquivo `urls.txt` com as variações de entrada de cada site (http e https, com e sem www, domínio antigo se houver, sempre com um caminho interno) e rode:

```bash
while read u; do
  echo "== $u"
  out=$(curl -sSIL --max-redirs 10 "$u" 2>&1) || echo "FALHA: $u"
  echo "$out" | grep -iE '^(HTTP|location|curl:)'
done < urls.txt
```

Qualquer entrada que mostre mais de um `Location` antes do `200`, ou que apareça como `FALHA` (certificado expirado, DNS quebrado, loop), entra na fila de correção. Se algum servidor tratar HEAD diferente de GET, troque `-I` por `-o /dev/null -D -`.

- Listar todas as variações de entrada, incluindo domínios antigos que ainda recebem links.
- Rodar o `curl` e anotar quem emite cada 301 (tabela acima).
- Escolher uma camada única por site e registrar qual foi, no documento do cliente.
- Aplicar a regra única com esquema e host finais.
- Desligar redirecionamentos de host no CDN, no painel e em plugins.
- Conferir `home` e `siteurl`.
- Revalidar todas as variações e repetir após renovação de certificado ou troca de CDN.

Guarde o `urls.txt` de cada cliente. Ele vira teste de regressão para a próxima migração.

## Como explicar ao cliente por que o site precisa de ajuste

O cliente não precisa saber o que é `Location`. Ele precisa entender por que você está cobrando por algo que "já funciona". Uma frase que costuma bastar:

"Hoje, quando alguém abre o seu site por um endereço antigo, o navegador é mandado de um lugar para outro algumas vezes antes de chegar na página. Cada desvio leva tempo, e só um deles já mede cerca de um décimo de segundo. Vou fazer o site mandar direto para o endereço certo na primeira resposta."

Se ele perguntar por que isso aconteceu, a resposta honesta é que cada mudança (HTTPS, domínio novo, hospedagem nova) adicionou uma regra sem remover a anterior. Não é erro de ninguém em particular, é falta de revisão depois da migração.

---

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