# Redirecionar centenas de URLs no .htaccess sem loop

Um bloco versionável no .htaccess, o critério para escolher entre lista 1:1, padrão com captura, pasta inteira e query string, e um teste em lote com curl que prova cada URL antes do deploy.

> são quatro as origens do ERR_TOO_MANY_REDIRECTS em migração de URLs: a regra que também casa com o destino, HTTPS forçado duas vezes, cadeia de 301 sobre 301 e RewriteBase errado. Coloque o bloco acima do bloco do WordPress e valide cada URL com curl -I: um 301 e um 200.

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

---

Refazer o site de um cliente muda o desenho das URLs. O que era `/blog/2019/03/titulo-do-post` vira `/artigos/titulo-do-post`, `/servicos.php?id=12` vira `/servicos/consultoria`, e a pasta `/institucional/` inteira passa a viver em `/sobre/`. São dezenas ou centenas de endereços, não um. E o erro que aparece meia hora depois do deploy quase sempre tem o mesmo nome no navegador do cliente: `ERR_TOO_MANY_REDIRECTS`.

O problema não é escrever a regra. É organizar o conjunto de regras de forma que você consiga revisar, versionar e testar antes de subir, e saber em qual das quatro situações típicas o loop nasceu.

## Trate a migração como um bloco único, acima do bloco do WordPress

O `.htaccess` de um WordPress já tem um bloco delimitado por comentários `# BEGIN WordPress` e `# END WordPress`. Esse bloco é reescrito pelo próprio WordPress quando você salva os links permanentes. Qualquer coisa que você escrever dentro dele some sem aviso.

Escreva o seu próprio bloco delimitado, acima dele:

```apache
# BEGIN MIGRACAO-2026-03 (exemplo)
# Redirecionamentos da reestruturacao de URLs.
# Nao editar dentro do bloco WordPress abaixo.
<IfModule mod_rewrite.c>
RewriteEngine On
RewriteBase /

# ...regras aqui...

</IfModule>
# END MIGRACAO-2026-03

# BEGIN WordPress
# ...bloco gerado pelo WordPress...
# END WordPress
```

Três motivos para o bloco ficar acima e ser delimitado:

- As regras do WordPress terminam mandando tudo que não é arquivo nem diretório para o `index.php`. Colocar seus redirecionamentos depois disso torna o comportamento dependente de detalhe de execução. Acima, eles são avaliados primeiro e a intenção fica explícita.
- Com marcadores `BEGIN`/`END` você consegue remover ou substituir a migração inteira num comando só, em qualquer um dos sites que você mantém.
- O bloco vira um arquivo versionável. Guarde `htaccess-migracao.txt` no repositório do projeto, junto com a planilha de de-para. No próximo site com a mesma situação, você copia e troca os caminhos.

Uma ressalva que economiza uma tarde de depuração: **não misture `Redirect`/`RedirectMatch` (mod_alias) com `RewriteRule` (mod_rewrite) para a mesma URL**. Os dois módulos atuam em fases diferentes do processamento da requisição, e a ordem em que você escreveu as linhas no arquivo não garante a ordem em que elas serão aplicadas entre módulos distintos. Dentro do mesmo módulo, sim, a ordem do arquivo vale. Escolha um módulo por conjunto de URLs.

A documentação do cPanel sobre [configuração manual de redirecionamentos](https://docs.cpanel.net/knowledge-base/general-systems-administration/how-to-configure-redirects-manually/) trata exatamente da edição do `.htaccess` para esse fim. Vale lembrar que a interface de Redirecionamentos do painel também escreve nesse mesmo arquivo. Se o cliente ou outro profissional já criou regras por lá, elas estão no `.htaccess` e vão conviver com as suas. Abra o arquivo antes de escrever qualquer coisa.

## Qual diretiva usar para cada tipo de mudança de URL

O erro mais comum de quem tem pressa é resolver tudo com lista 1:1. Funciona, mas gera um arquivo de 400 linhas que ninguém revisa. O critério é o padrão da mudança.

| Situação | Diretiva | Quando compensa |
|---|---|---||
| Poucas URLs, sem padrão entre origem e destino | `Redirect 301 /caminho-antigo /caminho-novo` | Até algumas dezenas de linhas, quando cada destino foi decidido a mão |
| Origem com padrão, destino idêntico exceto por um trecho | `RedirectMatch 301 ^/regex$ /destino` | Regra única cobre um grupo inteiro, sem precisar de condições |
| Padrão com parte variável que precisa ser reaproveitada | `RewriteRule ^padrao/(.*)$ /novo/$1 [R=301,L]` | Quando você precisa de captura, condições (`RewriteCond`) ou tratamento de query string |
| Pasta inteira mudou de nome, caminho interno preservado | `RewriteRule ^antiga/(.*)$ /nova/$1 [R=301,L]` | Migração de seção inteira, incluindo subníveis |
| URL antiga com query string virou caminho limpo | `RewriteCond %{QUERY_STRING}` + `RewriteRule` | Único jeito confiável, porque o padrão da `RewriteRule` não vê a query string |

### Lista 1:1 gerada a partir da planilha de de-para

Exemplo fictício, com endereços de demonstração:

```apache
Redirect 301 /institucional/quem-somos.html /sobre/
Redirect 301 /servicos/consultoria-tributaria.php /servicos/tributario/
Redirect 301 /contato.html /contato/
```

Gere essas linhas a partir da planilha de de-para, não a mão. Uma coluna com a URL antiga, outra com a nova, e uma fórmula que monta a linha. Copia e cola no arquivo. É o mesmo tempo de trabalho para 20 ou 200 linhas, e elimina erro de digitação.

### Padrão com captura, quando a URL perde a data

Quando o blog perdeu a data na URL:

```apache
# exemplo: /blog/2019/03/meu-post -> /artigos/meu-post
RewriteRule ^blog/[0-9]{4}/[0-9]{2}/(.+)$ /artigos/$1 [R=301,L]
```

O `$1` recebe o que a primeira captura casou. O `R=301` emite o redirecionamento permanente, o `L` interrompe o processamento das regras seguintes naquela passagem.

### Pasta que muda de nome preservando o caminho interno

```apache
# exemplo: /institucional/qualquer/coisa -> /sobre/qualquer/coisa
RewriteRule ^institucional/(.*)$ /sobre/$1 [R=301,L]
```

Essa é a regra que mais gera loop, pelo motivo do próximo bloco.

### Query string antiga virando caminho limpo

O padrão de uma `RewriteRule` casa apenas com o caminho, sem a query string. Para tratar `?id=12` você precisa de uma condição:

```apache
# exemplo: /servicos.php?id=12 -> /servicos/consultoria/
RewriteCond %{QUERY_STRING} ^id=12$
RewriteRule ^servicos\.php$ /servicos/consultoria/? [R=301,L]
```

O ponto de interrogação no fim do destino descarta a query string original. Sem ele, o mod_rewrite anexa a query original ao destino e o cliente recebe `/servicos/consultoria/?id=12`. Funciona, mas suja a URL nova e duplica endereço para o buscador.

## As quatro origens reais do loop

`ERR_TOO_MANY_REDIRECTS` no Chrome, `A página não está redirecionando corretamente` no Firefox. O navegador desiste depois de um número fixo de saltos. As causas, na prática, se resumem a quatro.

| Origem | Sintoma | Como confirmar | Correção |
|---|---|---|---||
| A regra também casa com o destino | Só a seção migrada quebra, o resto do site abre | `curl -I` na URL nova devolve 301 para ela mesma ou para um caminho que cresce | Excluir o destino do padrão com `RewriteCond` negativa |
| HTTPS forçado duas vezes | Site inteiro quebra, inclusive a home | A URL final é sempre a mesma, alternando ou repetindo | Manter um único ponto de força de HTTPS e respeitar `X-Forwarded-Proto` atrás de proxy |
| Cadeia 301 sobre 301 | Não é loop: consome saltos e dilui o rastreio, e só vira erro do navegador quando algum salto reaponta para endereço já visitado | `curl -IL` mostra 3, 4, 5 respostas antes do 200 | Reescrever as regras antigas para apontar direto ao destino final |
| `RewriteBase` errado | Site em subpasta quebra, o mesmo código na raiz funciona | O `Location` devolvido tem o prefixo da pasta duplicado ou faltando | Ajustar `RewriteBase` ao caminho real ou usar destinos absolutos |

### A regra que também casa com o próprio destino

O caso clássico da pasta:

```apache
# ERRADO (exemplo): /produtos/x -> /produtos/catalogo/x -> /produtos/catalogo/catalogo/x ...
RewriteRule ^produtos/(.*)$ /produtos/catalogo/$1 [R=301,L]
```

O destino `/produtos/catalogo/x` começa com `produtos/`, então casa com o mesmo padrão na requisição seguinte. O caminho cresce a cada volta até o navegador desistir.

A correção é excluir o destino explicitamente:

```apache
RewriteCond %{REQUEST_URI} !^/produtos/catalogo/
RewriteRule ^produtos/(.*)$ /produtos/catalogo/$1 [R=301,L]
```

Sempre que o destino for um subcaminho da origem, ou a origem for um prefixo genérico, escreva a `RewriteCond` negativa. É barato e evita o pior erro pós-deploy.

### HTTPS forçado em dois lugares ao mesmo tempo

Três lugares costumam forçar HTTPS no mesmo site: o painel de hospedagem, um plugin de SSL do WordPress e uma regra escrita a mão no `.htaccess`. Duas dessas fontes juntas raramente somam, elas brigam.

O caso mais traiçoeiro é o site atrás de proxy ou CDN. O visitante fala HTTPS com o proxy, o proxy fala HTTP com o servidor de origem. A variável `%{HTTPS}` no servidor vale `off` em toda requisição, a condição é sempre verdadeira, e o redirecionamento para HTTPS é emitido infinitamente.

```apache
# exemplo para origem atras de proxy que envia X-Forwarded-Proto
RewriteCond %{HTTP:X-Forwarded-Proto} !https
RewriteCond %{HTTPS} off
RewriteRule ^(.*)$ https://%{HTTP_HOST}/$1 [R=301,L]
```

Antes de escrever isso, confirme se o proxy realmente envia o cabeçalho. Se não envia, essa regra também não resolve, e o lugar certo de forçar HTTPS passa a ser o próprio proxy.

### Cadeia de 301 sobre 301 herdada de migração anterior

O site já passou por uma migração antes. As regras antigas continuam no arquivo. A URL de 2018 aponta para a de 2021, que agora aponta para a de 2026. Cada salto é um 301 legítimo, o navegador chega ao destino, e o Google segue a cadeia, mas você gastou três respostas onde uma bastava.

Quando alguém, em alguma dessas camadas, aponta de volta para um endereço já visitado, a cadeia vira ciclo e o navegador exibe o erro. Revise as regras antigas e aponte todas para o destino atual. Se a migração anterior já não tem mais tráfego de busca, apague as linhas.

### RewriteBase errado em site instalado em subpasta

Em site instalado numa subpasta, `RewriteBase /` faz com que substituições relativas sejam resolvidas a partir da raiz do domínio, e não da pasta. O resultado é um `Location` com prefixo errado, que bate de novo na mesma regra.

Duas saídas: acertar o `RewriteBase` para o caminho real (`RewriteBase /loja/`) ou escrever sempre destinos absolutos começando com `/`. A segunda é mais previsível quando você padroniza o mesmo bloco em vários sites com estruturas diferentes.

## Teste em lote com curl, antes de o cliente reclamar

O teste manual no navegador mente. O navegador guarda 301 em cache de forma agressiva, e depois de testar uma vez errado, você passa a testar o cache e não a regra. Teste com `curl`, que não guarda nada.

### Monte a lista de URLs antigas

Um arquivo `urls-antigas.txt`, uma URL completa por linha, tirado da planilha de de-para, do sitemap antigo ou do relatório de páginas do Search Console:

```
https://exemplo.com.br/institucional/quem-somos.html
https://exemplo.com.br/blog/2019/03/meu-post
https://exemplo.com.br/servicos.php?id=12
```

### Verifique o primeiro salto de cada URL

```bash
while read -r url; do
  printf '%s -> ' "$url"
  curl -s -o /dev/null -I -w '%{http_code} %{redirect_url}\n' "$url"
done < urls-antigas.txt
```

O que você quer ver em cada linha: um código de redirecionamento e a URL nova correta. Na fase de validação do checklist, com o bloco ainda em `R=302`, o esperado é `302`; o `301` só é exigido no laço final, depois da troca. Se aparecer `200`, a regra não casou e a URL antiga continua servindo conteúdo, o que gera duplicidade. Se o `redirect_url` for igual à URL de origem, achou o loop.

### Verifique a cadeia completa até o destino

```bash
while read -r url; do
  printf '%s -> ' "$url"
  curl -s -o /dev/null -L --max-redirs 5 \
    -w '%{http_code} saltos=%{num_redirects} final=%{url_effective}\n' "$url"
done < urls-antigas.txt
```

O resultado aceitável é `200 saltos=1` e a URL final igual ao destino planejado. `saltos=2` já indica cadeia (por exemplo, a regra manda para HTTP e depois a força de HTTPS manda de novo). Com `--max-redirs 5`, o `curl` aborta em vez de girar para sempre, e o loop aparece como erro em vez de travar o terminal.

### Ver a cadeia inteira de uma URL específica

```bash
curl -sIL https://exemplo.com.br/institucional/quem-somos.html | grep -i -E '^HTTP/|^location:'
```

Essa é a saída que você cola no ticket ou no e-mail quando precisa provar o comportamento para outra pessoa da equipe.

## Checklist de deploy, reutilizável em qualquer site

- **Copie o `.htaccess` atual** para `.htaccess.bak-AAAAMMDD` antes de editar. Se o site cair, a reversão é um `mv`.
- **Leia o arquivo inteiro.** Anote redirecionamentos que já existem, inclusive os criados pela interface do painel, e a regra de HTTPS, se houver.
- **Monte a planilha de de-para** com URL antiga, URL nova e o tipo de regra que cada linha vai virar. Agrupe o que tem padrão.
- **Gere o bloco** com marcadores `# BEGIN`/`# END` e um módulo só por conjunto de URLs.
- **Suba primeiro com `R=302`.** Redirecionamento temporário não fica no cache do navegador nem consolida sinal no buscador. Se a regra estiver errada, o estrago é reversível.
- **Rode os dois laços de `curl`** contra a lista completa. Todo mundo precisa terminar em `200` com um salto.
- **Troque `302` por `301`** e rode o primeiro laço de novo, confirmando o código 301.
- **Guarde o bloco no repositório** do projeto, com a data no nome, junto da planilha.
- **Reenvie o sitemap novo** no Search Console e deixe as URLs antigas fora dele.

O passo do `R=302` é o que mais poupa retrabalho. Um 301 errado servido por algumas horas continua no cache dos navegadores dos visitantes depois que você corrigiu o arquivo, e o cliente jura que o site ainda está quebrado.

## Como explicar o problema para o cliente

O cliente final não precisa saber o que é mod_rewrite. Precisa saber por que o site dele ficou inacessível e por que não vai acontecer de novo.

Uma frase que funciona: *"Os endereços antigos das páginas foram reapontados para os novos. Uma dessas regras estava apontando um endereço para ele mesmo, e o navegador entrou num círculo. A regra foi corrigida e todos os endereços antigos foram testados um a um: cada um agora leva direto à página certa, em um único passo."*

E, se ele perguntar por que não simplesmente deixar as páginas antigas fora do ar: *"Quem já tinha o link antigo salvo, ou clicou num resultado do Google que ainda aponta para o endereço antigo, veria erro 404. O redirecionamento permanente transfere para o endereço novo tanto a visita quanto a reputação que aquela página já tinha na busca."*

Duas frases, sem jargão, e resolvem a conversa.

## O que checar quando o erro não é loop

Nem todo problema pós-deploy de redirecionamento é ciclo. Três vizinhos frequentes:

- **Erro 500 logo após salvar o arquivo.** Quase sempre é sintaxe: uma expressão regular malformada, um `<IfModule>` sem fechamento, ou uma diretiva que o servidor não permite em `.htaccess`. Restaure o backup, volte metade das regras e repita até isolar a linha.
- **A regra não dispara.** Confira se o caminho no padrão começa sem barra (em `.htaccess`, o padrão da `RewriteRule` não inclui a barra inicial) e se a URL testada tem, ou não, barra no fim. `/sobre` e `/sobre/` são caminhos diferentes para o padrão.
- **Tudo funciona no `curl` e falha no navegador.** É cache do próprio navegador guardando um 301 antigo. Teste em janela anônima ou em outro dispositivo antes de mexer de novo no arquivo.

Quando o conjunto de regras passa de algumas centenas de linhas, vale medir se o `.htaccess` deixou de ser o lugar certo. Toda requisição do site lê e interpreta esse arquivo, em cada diretório do caminho. Reduzir lista 1:1 a padrões com captura resolve o volume na maioria das migrações, e é a razão de escolher o tipo de regra pelo padrão da mudança, não pela pressa.

