# www ou sem www: qual escolher e os 108 ms do salto

Medimos o pedágio do 301 entre www e raiz na mesma página e no mesmo servidor, e juntamos ao procedimento de troca no WordPress que não deixa você trancado fora do wp-admin.

> Tanto faz escolher www ou a raiz: o custo está em manter os dois endereços em uso. Entrar pelo endereço com www e ser redirecionado para a raiz custou 241,6 ms medianos, contra 133,9 ms indo direto ao canônico. São +108 ms na primeira entrada, mesma página, mesmo servidor.

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

---

Este guia reúne num lugar só o que antes estava espalhado em três textos nossos: a medição do custo de entrar pelo endereço não canônico, o procedimento para trocar o canônico no WordPress sem perder o acesso ao painel, e a auditoria em lote para quem cuida de vários sites.

A frase repetida em todo fórum está certa pela metade. "www ou sem www, tanto faz, escolha um e redirecione o outro": a parte do "escolha um" é verdade. A parte que ninguém coloca preço é o que acontece com quem entra pelo endereço que sobrou.

## Os 108 ms que o salto entre www e raiz cobra

Medimos na mesma página, no mesmo servidor, a partir de um VPS externo, 100 requisições em cada cenário. Entrar pelo endereço com `www`, receber um 301 e ser levado até a raiz custou **241,6 ms** medianos de tempo total. Ir direto ao endereço canônico custou **133,9 ms**. A diferença é de **108 ms** para carregar exatamente o mesmo HTML.

| Entrada | Tempo total mediano | Diferença |
|---|---|---||
| Direto no canônico (raiz) | 133,9 ms | referência |
| Com `www`, 301 para a raiz | 241,6 ms | +108 ms |

Não é uma tragédia. É um pedágio silencioso que se paga em toda campanha mal apontada, todo link antigo, todo cartão de visita impresso com o endereço "errado", multiplicado por quantos sites você mantém.

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

## Por que um 301 entre hosts cobra DNS, TCP e TLS de novo

O 301 em si é uma resposta minúscula: cabeçalho, `Location`, corpo vazio. Se o custo fosse só isso, seria ruído. O custo real está no que o cliente faz **depois** de ler o `Location`.

Quando o destino do redirecionamento é um host diferente (`www.exemplo.com.br` e `exemplo.com.br` são hosts diferentes, mesmo apontando para o mesmo IP), o caminho pode ter que ser refeito inteiro:

- resolução DNS do novo host, se ainda não estiver em cache;
- abertura de conexão TCP nova;
- handshake TLS novo, com certificado, cadeia e verificação;
- só então o `GET` da página que ele já queria desde o começo.

Uma ressalva importante, e ela muda o tamanho do problema em parte dos casos: **navegador moderno pode reaproveitar a conexão**. Se os dois hosts resolvem para o mesmo IP, o certificado cobre os dois nomes (SAN com `exemplo.com.br` e `www.exemplo.com.br`) e a conexão é HTTP/2, o navegador tende a fazer *connection coalescing*: reusa a conexão já aberta e paga só o RTT do novo `GET`, sem DNS, sem TCP e sem TLS extras. Certificado emitido só para um dos nomes, IPs diferentes ou HTTP/1.1 quebram essa otimização e o custo volta ao caminho completo.

O `curl` não faz coalescing entre hosts. Ou seja, os 108 ms que medimos representam o **pior caso**: conexão nova a cada salto que muda de host, como acontece com quem tem certificado de um nome só, com robôs e ferramentas que não coalescem, e com qualquer cliente em HTTP/1.1. Em rede pior, com RTT alto, o mesmo desenho custa mais, porque DNS, TCP e TLS são todos sensíveis a ida e volta. Não medimos móvel nem 3G, então não vou colocar número nisso, mas a estrutura do custo é a mesma e cresce junto com a latência.

Mais dois detalhes honestos que atenuam o problema, e você deve saber deles antes de vender urgência ao cliente:

- **O navegador guarda 301 permanentes.** Na segunda visita do mesmo usuário, o salto tende a ser resolvido localmente. Quem paga o pedágio é a primeira visita, que é justamente a de campanha, a de link externo e a do robô de busca.
- **`curl` não guarda nada.** Cada medição nossa foi como uma primeira visita. Isso é bom para comparar cenários e ruim se você usar o número como se fosse a experiência média de um usuário recorrente.

O que generaliza da medição não é o valor absoluto, que depende do servidor, da rota e do certificado. É a forma do custo: um salto entre hosts diferentes cobra, no pior caso, um DNS, um TCP e um TLS a mais, e no melhor caso ainda cobra uma ida e volta.

## Escolher entre www e raiz e trocar no WordPress sem perder o painel

Do ponto de vista de desempenho, tanto faz mesmo. O que não pode existir é ambiguidade. Escolha em função disto:

- **Use a raiz** (`exemplo.com.br`) se o cliente vai imprimir o endereço, ditar por telefone ou colocar em rádio. É mais curto e ninguém erra.
- **Use `www`** se o domínio precisa de CNAME no topo (CDN, alguns SaaS) ou se você quer isolar cookies do domínio raiz de outros subdomínios. `www` é um subdomínio de verdade, aceita CNAME sem gambiarra.
- **Mantenha o que já está no ar** se o site tem histórico, links e ranking. Trocar o canônico de um site estabelecido é uma migração, com todo o custo de uma migração, para ganhar zero.

E fique claro: **o redirecionamento continua existindo**. Você não apaga o 301 do endereço não canônico, senão quem digitar `www` bate em erro. O objetivo é que ninguém precise passar por ele.

### A ordem que evita o loop de redirecionamento

O jeito mais comum de perder o wp-admin numa troca de canônico é este: você põe a regra no `.htaccess` mandando tudo para a raiz, mas `siteurl` no banco continua com `www`. O WordPress recebe o pedido na raiz, devolve 301 para `www`, o Apache devolve 301 para a raiz, e o navegador desiste com `ERR_TOO_MANY_REDIRECTS`. O site fica fora e o painel também.

Faça nesta ordem:

- Alinhe `home` e `siteurl` com o canônico escolhido.
- Só depois publique a regra de redirecionamento no `.htaccess`.
- Valide com `curl` antes de abrir o navegador, que guarda 301 em cache e atrapalha o diagnóstico.

Com WP-CLI:

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

Os dois valores têm que bater exatamente com o canônico, com esquema `https://` e sem barra final.

Sem WP-CLI, ou se você já está trancado do lado de fora, use o `wp-config.php` como saída de emergência. Essas duas constantes têm precedência sobre o que está no banco e resolvem o loop na hora:

```php
define( 'WP_HOME', 'https://exemplo.com.br' );
define( 'WP_SITEURL', 'https://exemplo.com.br' );
```

Com elas definidas, os campos de endereço em Configurações ficam travados, o que é bom durante a troca e ruim se você esquecer que estão lá. Deixe um comentário na linha de cima.

Dois efeitos colaterais esperados, para não assustar:

- **Você vai ser deslogado.** O cookie de sessão é do host antigo. Faça login de novo no endereço canônico.
- **A primeira tentativa pode vir do cache do seu navegador.** Se o comportamento não mudar, teste em janela anônima ou com `curl`, que não guarda 301.

Se o site já estiver em loop e você não tiver acesso a nada além de FTP ou gerenciador de arquivos: renomeie o `.htaccess` para `htaccess.off`, entre no painel, arrume `home` e `siteurl`, e só então devolva o arquivo com a regra correta.

## Ver a cadeia de saltos de um domínio com um comando curl

Antes de mexer em qualquer coisa, veja o que está no ar. Um comando por domínio mostra a cadeia inteira:

```bash
curl -sIL http://www.exemplo.com.br | grep -Ei '^(HTTP/|location:)'
```

Saída de um site bem configurado, um salto só:

```
HTTP/1.1 301 Moved Permanently
location: https://exemplo.com.br/
HTTP/2 200
```

Saída de um site com cadeia, três saltos para chegar na mesma página:

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

Uma ressalva: `-I` envia `HEAD`, e alguns servidores ou plugins tratam `HEAD` diferente de `GET`. Se a saída parecer estranha, repita com `curl -sL -o /dev/null -D - URL` para fazer um `GET` de verdade e ainda ver os cabeçalhos.

### Varrer a carteira inteira em lote e ordenar por número de saltos

Um site pode estar impecável entrando por uma porta e péssimo em outra, então o loop precisa testar as quatro portas de entrada de cada domínio. Coloque em `dominios.txt` apenas o domínio nu, um por linha (`exemplo.com.br`, sem esquema e sem `www`), e deixe o script montar as combinações:

```bash
while read -r d; do
  for prefixo in 'http://' 'http://www.' 'https://' 'https://www.'; do
    url="${prefixo}${d}"
    printf '%-40s ' "$url"
    curl -sIL -o /dev/null \
      -w '%{num_redirects} saltos  %{time_total}s  -> %{url_effective}\n' \
      "$url"
  done
done < dominios.txt
```

Você recebe quatro linhas por site, uma para cada porta de entrada, com número de saltos, tempo total e URL final. Ordene por `num_redirects` e leia assim:

- entrando por `http://` ou `http://www.`, **1 salto** é o mínimo possível (o redirecionamento obrigatório para HTTPS). Dois ou mais é trabalho a fazer;
- entrando por `https://` no host canônico, o esperado é **0 saltos**;
- entrando por `https://` no host não canônico, o esperado é **1 salto**.

Se você já mantém uma lista com URLs completas, troque o `for` por `curl ... "$d"` e use o arquivo direto, com uma URL completa por linha. O que não funciona é fixar `http://` no comando e esperar testar HTTPS.

## Medir o pedágio em milissegundos, não em adjetivo

Contar saltos mostra o defeito. Medir mostra o preço, e é o que convence cliente. Use um arquivo de formato para não repetir string gigante:

```bash
cat > fmt.txt <<'EOF'
     dns:  %{time_namelookup}s
     tcp:  %{time_connect}s
     tls:  %{time_appconnect}s
  1o byte: %{time_starttransfer}s
   redir:  %{time_redirect}s (%{num_redirects} saltos)
   TOTAL:  %{time_total}s -> %{url_effective}
EOF

curl -sL -o /dev/null -w "@fmt.txt" https://www.exemplo.com.br
curl -sL -o /dev/null -w "@fmt.txt" https://exemplo.com.br
```

Duas coisas para ler com atenção na saída:

- `time_redirect` é o tempo gasto em todos os saltos anteriores ao último. É literalmente o pedágio, isolado.
- Com `-L`, `time_namelookup`, `time_connect` e `time_appconnect` se referem ao **último** salto. Por isso o `time_total` pode ser muito maior que a soma que você lê ali: o DNS, o TCP e o TLS do primeiro host estão embutidos no `time_redirect`.

Lembre que o `curl` não reaproveita conexão quando o salto muda de host: aí ele refaz DNS, TCP e TLS. Se o salto for dentro do mesmo host (o caso da barra final, por exemplo), ele reusa a conexão já aberta e o custo é só mais uma ida e volta. Se quiser saber o que o navegador do usuário realmente paga no salto entre `www` e raiz, abra o painel de rede com cache desativado e compare: quando há coalescing, o segundo salto aparece sem fase de conexão.

Rode cada cenário várias vezes e compare medianas, nunca uma amostra única. Rede tem cauda. Uma execução isolada pega justamente a que atrasou e você conclui besteira. Nossa medição usou 100 requisições por cenário exatamente por isso.

## Os quatro defeitos que criam salto a mais

Esta é a lista que resolve quase tudo o que aparece numa varredura de carteira.

### Regras de HTTPS e de www separadas no .htaccess viram dois 301

O padrão clássico: uma regra força HTTPS, outra remove o `www`, e as duas rodam em requisições separadas. Resultado: `http://www` para `https://www` para `https://raiz`, dois 301 em vez de um.

A correção é uma regra só que decide o destino final de uma vez:

```apache
RewriteEngine On
RewriteCond %{HTTPS} !=on [OR]
RewriteCond %{HTTP_HOST} ^www\. [NC]
RewriteRule ^ https://exemplo.com.br%{REQUEST_URI} [R=301,L]
```

Coloque antes do bloco do WordPress, dentro do `.htaccess` da raiz, e apague as regras antigas de HTTPS e de `www` que existiam soltas. Depois valide com o `curl -sIL`: tem que sair um 301 e um 200.

Se o canônico do cliente for com `www`, é o espelho:

```apache
RewriteEngine On
RewriteCond %{HTTPS} !=on [OR]
RewriteCond %{HTTP_HOST} !^www\. [NC]
RewriteRule ^ https://www.exemplo.com.br%{REQUEST_URI} [R=301,L]
```

### Barra final divergente entre link interno e canônico

`/contato` e `/contato/` são URLs diferentes. O WordPress normalmente responde 301 de uma para a outra. Se o menu, o link do rodapé ou o botão da campanha usa a forma sem barra e o site canoniza com barra, você criou um salto extra em cada clique interno.

Esse salto é mais barato que o de `www` para raiz, porque acontece dentro do mesmo host e reaproveita a conexão. Ainda assim é uma ida e volta a mais em cada clique. Verifique como o site canoniza e padronize os links internos na mesma forma. É achado comum em menu editado à mão e em botão de página construída com page builder.

### Plugin de SSL e plugin de SEO redirecionando por cima do servidor

Plugin de SSL que "força HTTPS" e plugin de SEO que "força www" ligados ao mesmo tempo são fonte recorrente de salto duplicado, e às vezes de loop. Deixe um responsável só pela regra, de preferência o servidor, e desligue a opção equivalente nos plugins. Depois confira de novo `home` e `siteurl`: alguns plugins reescrevem essas opções sozinhos.

### Links e campanhas apontando para o endereço não canônico

Este é o que efetivamente cobra o pedágio do usuário real. Anúncio, e-mail marketing, assinatura de e-mail, perfil de rede social, QR code, link em parceiro. Todos costumam guardar a versão antiga do endereço.

Corrija na origem. É o único conserto que elimina o salto de verdade, porque os outros três apenas encurtam a cadeia.

### Do sintoma na varredura até a causa provável e a correção

| Sintoma na varredura | Causa provável | Correção |
|---|---|---||
| 2 saltos entrando por `http://www` | regra de HTTPS e regra de `www` separadas | uma `RewriteRule` única com as duas condições |
| 301 em link interno de menu | barra final divergente | padronizar links internos na forma canônica |
| `ERR_TOO_MANY_REDIRECTS` no site e no painel | `home`/`siteurl` apontando para o host oposto ao do `.htaccess` | alinhar as opções, ou usar `WP_HOME`/`WP_SITEURL` no `wp-config.php` |
| Cadeia só em algumas páginas | redirecionamento antigo de migração apontando para URL que também redireciona | reescrever a regra antiga para o destino final |
| Site rápido no teste, lento para o cliente | campanha apontando para o host não canônico | trocar a URL na origem da campanha |
| Salto entre `www` e raiz caro mesmo em navegador | certificado cobre só um dos nomes, sem coalescing | emitir certificado com os dois nomes no SAN |

## Checklist de padronização para quem cuida de vários sites

O que vale numa agência não é consertar um site, é ter um procedimento que se repete sem pensar. Este é reutilizável:

- Definir o canônico do cliente e **registrar em algum lugar** (ficha do projeto, README do repositório). Sem registro, o próximo freela desfaz.
- Rodar a varredura em lote nas quatro portas de entrada e guardar a saída como "antes".
- Alinhar `home` e `siteurl` com WP-CLI, antes de mexer no `.htaccess`.
- Corrigir o `.htaccess` com regra única, apagando as antigas.
- Conferir se o certificado cobre `exemplo.com.br` e `www.exemplo.com.br`. Além de evitar erro para quem digita o outro nome, é o que permite ao navegador reaproveitar a conexão no salto.
- Procurar links internos absolutos apontando para o host não canônico. Se for trocar em banco, faça `--dry-run` primeiro e tenha backup: `wp search-replace 'https://www.exemplo.com.br' 'https://exemplo.com.br' --dry-run`.
- Atualizar campanhas, assinatura de e-mail, perfis e QR codes para o endereço final.
- Confirmar que o Search Console tem a propriedade de domínio, e que o sitemap lista apenas URLs canônicas, sem redirecionamento interno.
- Rodar a varredura de novo e guardar como "depois". A diferença entre as duas saídas é o seu relatório.

O último passo é o que transforma manutenção invisível em item de proposta. Você entrega duas listas: antes com 3 saltos, depois com 1, com tempo medido em cada uma.

## Como explicar ao cliente e o que a medição não diz

O cliente não quer saber de handshake. Ele quer saber se está quebrado e se precisa pagar por algo. A resposta honesta é: não está quebrado, e o conserto é de configuração.

Frase pronta, pode copiar:

> **** O site não está com defeito. Acontece que ele tem dois endereços, um com `www` e um sem, e o oficial é só um. Quando alguém entra pelo outro, o servidor precisa avisar o navegador qual é o certo, e o navegador recomeça no endereço oficial. Numa medição nossa, esse desvio somou 108 ms na primeira vez que a pessoa entra, na mesma página e no mesmo servidor. Vamos deixar um endereço só como oficial e apontar seus anúncios e links direto para ele, para ninguém mais passar por esse desvio.

Se o cliente perguntar se isso derruba o Google: não é esse o argumento. Um 301 bem feito preserva o destino e é a forma correta de dizer ao buscador qual endereço vale. O problema de cadeia longa é desperdício, de tempo do usuário e de rastreamento, não punição.

E os limites do número, para não vendê-lo além do que ele suporta:

- Medimos **uma** página, em **um** servidor, a partir de um VPS externo com rota estável. O valor absoluto seria outro em rede residencial ou móvel.
- Medimos com `curl`, que não reaproveita cache de redirecionamento nem faz coalescing de conexão entre hosts diferentes. Navegador faz os dois quando as condições permitem. O número é o pior caso, não a média do usuário recorrente.
- Não medimos HTTP/3, não medimos com CDN na frente, não medimos cenário de cadeia com três saltos. O custo de cadeia mais longa é maior, mas quanto maior nós não sabemos, porque não medimos.
- Não medimos impacto em posição de busca. Ninguém consegue medir isso de forma limpa, e quem diz que mediu está inferindo.

O que sustenta a decisão é isto: existe um custo em milissegundos, ele é reprodutível com dois comandos `curl`, e ele desaparece quando o usuário entra direto no endereço canônico. O resto é processo.

---

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