# Como diagnosticar TTFB alto no WordPress com curl

O curl entrega DNS, TCP, TLS e primeiro byte separados em uma única linha de comando. Com 100 amostras e a mediana, dá para dizer se o tempo está no servidor, na rede ou depois do primeiro byte.

> o TTFB é o campo `time_starttransfer` do curl, e a leitura que acusa a hospedagem é ele menos `time_pretransfer`. Colete 100 amostras, use a mediana e decomponha em DNS, TCP, TLS e primeiro byte antes de trocar de plano.

João Rizzon · 2026-09-14 · WordPress

---

Site lento tem muitos culpados possíveis e quase sempre o mesmo acusado: a hospedagem. Só que "lento" é uma sensação, e sensação não se conserta. O que se conserta é um número.

O número mais barato de obter e o mais revelador para WordPress é o TTFB, o tempo até o primeiro byte da resposta. Ele separa duas coisas que costumam ser confundidas: o tempo que o servidor gasta gerando a página em PHP e o tempo que o navegador gasta baixando imagem, CSS e JavaScript. Um site pode ter TTFB de 2 segundos e carregar tudo o resto em 300 ms. Nesse caso, comprimir imagem não resolve nada.

O que segue é o procedimento de medição: como pedir a linha do tempo ao curl, como coletar 100 amostras sem se enganar, como ler cada campo e quais erros invalidam a coleta inteira. O efeito do cache de página sobre esse número está medido e explicado em [site demora para abrir: 116 ms com cache, 1.786 ms sem](/wordpress/site-demora-para-abrir-116-ms-com-cache-1-786-ms-sem), com a metodologia completa da coleta. Aqui ele entra só como referência de escala.

## O que o curl chama de TTFB, e as duas leituras que saem dele

O curl expõe uma linha do tempo da requisição em variáveis de escrita (`-w`). Cada uma é acumulada desde o início da requisição, não é a duração isolada da etapa. Para saber quanto durou o TLS, você subtrai `time_connect` de `time_appconnect`.

| Variável | O que já aconteceu quando ela é marcada |
|---|---||
| `time_namelookup` | resolução DNS do domínio concluída |
| `time_connect` | handshake TCP concluído |
| `time_appconnect` | handshake TLS concluído (0 em HTTP simples) |
| `time_pretransfer` | conexão pronta, requisição prestes a ser enviada |
| `time_starttransfer` | primeiro byte da resposta chegou |
| `time_total` | resposta inteira recebida e conexão encerrada |

Duas leituras diferentes saem daí:

- **TTFB de ponta a ponta** é `time_starttransfer`. Inclui DNS, TCP, TLS e a rede entre você e o servidor. É o que o visitante sente na primeira requisição.
- **Tempo do servidor** é `time_starttransfer` menos `time_pretransfer`. É o intervalo em que a bola estava com o servidor: PHP, banco de dados, plugin, tema.

Quando alguém diz "meu TTFB está alto", quase sempre está falando do primeiro. Quando alguém diz "a hospedagem está lenta", está acusando o segundo. Não são a mesma coisa e a diferença entre eles é medível em uma linha de comando.

**15×** diferença de TTFB mediano da mesma página WordPress com e sem cache de página (116 ms contra 1.786 ms) (n=100, setembro de 2026)

## Como medir o TTFB da sua URL com 100 requisições curl

### Crie o arquivo de formato do curl

Salve como `curl-format.txt`:

```
     dns: %{time_namelookup}s
     tcp: %{time_connect}s
     tls: %{time_appconnect}s
  pre-tx: %{time_pretransfer}s
    ttfb: %{time_starttransfer}s
   total: %{time_total}s
  codigo: %{http_code}
  tamanho: %{size_download} bytes
```

Uma requisição só, para ver a decomposição:

```bash
curl -s -o /dev/null -w "@curl-format.txt" https://seusite.com.br/
```

### Colete 100 amostras do primeiro byte

Uma requisição não vale nada. A variação entre execuções é grande o suficiente para você provar qualquer tese que quiser com uma amostra só. Colete 100 e olhe a mediana.

```bash
for i in $(seq 1 100); do
  curl -s -o /dev/null -w "%{time_starttransfer}\n" https://seusite.com.br/
  sleep 1
done > ttfb.txt
```

O `sleep 1` existe para não disparar 100 requisições em rajada e medir você mesmo saturando o servidor, o que responderia outra pergunta.

### Calcule a mediana e por que a média engana

```bash
sort -n ttfb.txt | awk '{a[NR]=$1} END {print a[int(NR/2)]}'
```

Com 100 linhas, isso imprime o 50º valor da lista ordenada. É a mediana inferior, e serve. Use mediana e não média: uma única requisição de 8 segundos, porque o wp-cron disparou naquele instante, empurra a média para cima e esconde o comportamento típico.

Multiplique por 1000 para ler em milissegundos. `0.116` é 116 ms.

### Repita a coleta sem cache para ter o par de números

Só existe comparação se você medir os dois lados. Duas formas de furar o cache de página:

```bash
# opção A: query string aleatória (a maioria dos caches trata como URL nova)
curl -s -o /dev/null -w "%{time_starttransfer}\n" "https://seusite.com.br/?nc=$RANDOM"

# opção B: desligar o cache no plugin e rodar o mesmo loop
```

A opção A é a mais rápida e não mexe no site em produção. Confira o cabeçalho de cache antes e depois para ter certeza de que você realmente furou:

```bash
curl -sI "https://seusite.com.br/?nc=$RANDOM" | grep -iE 'x-cache|cf-cache-status|x-litespeed-cache|age|cache-control'
```

Se o cabeçalho diz `HIT` nas duas medições, você mediu a mesma coisa duas vezes.

## Como ler os quatro campos e decidir onde mexer

Com a decomposição na mão, a conclusão sai quase sozinha. O que segue é regra de leitura, não medição: são os padrões que aparecem com mais frequência quando se olha esses quatro campos juntos.

| Onde está o tempo | Interpretação | Onde mexer |
|---|---|---||
| `time_starttransfer` menos `time_pretransfer` é a maior fatia | o servidor está gastando o tempo gerando a página | cache de página, plugin, query lenta, versão do PHP |
| `time_namelookup` é alto e varia muito entre execuções | DNS lento ou TTL muito baixo | provedor de DNS, TTL do registro |
| `time_connect` menos `time_namelookup` é alto | distância de rede ou rota ruim até o servidor | região do servidor, CDN |
| `time_appconnect` menos `time_connect` é alto | handshake TLS caro | reuso de conexão, HTTP/2, cadeia de certificado |
| tudo baixo, mas o site parece lento no navegador | o problema não é TTFB | imagem, JavaScript, fonte, render bloqueado |

Um detalhe que engana muita gente: cada invocação do curl abre uma conexão nova, então DNS, TCP e TLS entram em **todas** as 100 amostras. No navegador, isso acontece uma vez e as requisições seguintes reaproveitam a conexão. Ou seja, o curl superestima a fatia de rede e subestima o peso relativo do PHP na navegação real. Se quiser tirar o DNS da conta, fixe o IP:

```bash
curl -s -o /dev/null -w "%{time_starttransfer}\n" \
  --resolve seusite.com.br:443:203.0.113.10 https://seusite.com.br/
```

## Que ordem de grandeza esperar entre os dois números

Se a coleta com cache e a coleta sem cache derem valores próximos, quase sempre a conclusão não é "o cache não adianta", é "o cache não estava pegando". A diferença entre os dois cenários costuma ser de ordem de grandeza, não de alguns por cento, porque com o HTML pronto o servidor deixa de fazer a maior parte do trabalho em vez de fazê-lo mais rápido.

Como referência de escala, em teste controlado de laboratório a mesma página WordPress no mesmo servidor teve TTFB mediano de 1.786 ms sem cache de página e 116 ms com cache, em 100 requisições curl por cenário. Quinze vezes. A metodologia da coleta, a diferença entre cache servido pelo servidor web e cache por plugin e os cuidados com página não cacheável estão no artigo [site demora para abrir: 116 ms com cache, 1.786 ms sem](/wordpress/site-demora-para-abrir-116-ms-com-cache-1-786-ms-sem).

O que interessa aqui é o uso diagnóstico do par: ele diz se o custo está na geração da página ou em outro lugar. Se as duas medianas forem parecidas, o próximo passo é conferir cabeçalho de cache e cookie de sessão, não trocar de plano.

## As rotas do WordPress em que o cache de página não ajuda

Existe um conjunto de rotas do WordPress em que o cache de página não ajuda porque elas não podem ser cacheadas. Se a reclamação de lentidão vem de dentro do painel, o loop acima na home não vai reproduzir o problema.

### Por que /wp-admin/ lento não aparece na medição da home

`/wp-admin/` nunca é servido de cache de página. Se ele está lento, meça ele. Autentique o curl com o cookie de sessão, ou apenas cronometre no navegador com a aba de rede aberta e olhe o campo de espera da primeira requisição do documento.

### Como medir admin-ajax.php e a REST API separadamente

Plugin de formulário, carrinho e contador em tempo real batem em `admin-ajax.php` a cada carregamento. Um GET vazio nessa rota não serve de medição: sem o parâmetro `action`, o WordPress responde `0` ou `-1` com HTTP 400 quase instantaneamente, e o número que sai não tem nada a ver com o trabalho que o plugin faz de verdade.

Pegue a chamada real na aba de rede do navegador (nome da `action` e demais campos do corpo) e reproduza com os mesmos parâmetros, conferindo o código de resposta em toda coleta:

```bash
curl -s -o /dev/null \
  -w "ttfb=%{time_starttransfer} http=%{http_code}\n" \
  -d 'action=meu_plugin_acao&id=123' \
  https://seusite.com.br/wp-admin/admin-ajax.php
```

Se o `http_code` vier 400, você mediu a rejeição, não a rota. Só vale a amostra com 200.

A REST API se mede do mesmo jeito, com a vantagem de que boa parte das rotas públicas responde a GET simples:

```bash
curl -s -o /dev/null \
  -w "ttfb=%{time_starttransfer} http=%{http_code}\n" \
  "https://seusite.com.br/wp-json/wp/v2/posts?per_page=10"
```

Rota que exige autenticação vai devolver 401. Nesse caso, mande o cookie de sessão e o nonce, ou uma senha de aplicativo, antes de acreditar no número.

### Por que o wp-cron cria as amostras extremas e como tirá-lo da conta

Por padrão, o WordPress dispara as tarefas agendadas dentro de uma visita real. O visitante sorteado paga a conta. Isso aparece na sua coleta como um punhado de amostras muito acima das outras, o que é exatamente o motivo de usar mediana e olhar também os valores extremos do arquivo:

```bash
sort -n ttfb.txt | tail -5
```

Se os cinco maiores estão muito distantes da mediana, desligue o disparo interno no `wp-config.php` e agende pelo cron do sistema:

```php
define( 'DISABLE_WP_CRON', true );
```

```bash
# uma execução a cada 5 minutos, no crontab do sistema
*/5 * * * * curl -s https://seusite.com.br/wp-cron.php?doing_wp_cron > /dev/null
```

Se você desligar o disparo interno e esquecer de agendar, as tarefas simplesmente param de rodar. Backup, publicação agendada e envio de e-mail dependem disso.

### Quando o culpado é uma query lenta e o plano maior só mascara

Quando o TTFB sem cache é alto e não melhora com nada do que está acima, o próximo lugar é o log de consulta lenta do MySQL. Dois casos diferentes produzem esse sintoma e é bom não confundi-los na hora de procurar:

- **Opção gigante com autoload em `wp_options`.** O WordPress carrega todas as linhas com `autoload = yes` em cada requisição. Um plugin que guarda megabytes de log ou de transient nessa tabela faz o custo aparecer em toda página, mesmo sem query complicada.
- **`meta_query` sem índice útil em `wp_postmeta`.** Filtro de produto, campo personalizado ou listagem que busca por `meta_key`/`meta_value` em uma tabela grande varre linhas demais e aparece direto no log de consulta lenta.

Vale dizer o óbvio: se o problema é uma query, mudar de plano ou de servidor pode mascarar por um tempo e não resolve. A query continua lá, só rodando em hardware mais caro.

## Cinco erros que invalidam a medição de TTFB

- **Medir a partir do próprio servidor.** `curl localhost` mede o PHP sem rede, o que é útil para isolar, mas não é o que o visitante sente. Meça dos dois lugares e compare.
- **Medir logado.** Com cookie de sessão do WordPress, o cache de página é ignorado. Você vai medir sempre o pior caso e concluir que o cache não funciona.
- **Medir uma URL que redireciona.** Sem `-L`, o curl mede o tempo do 301 e você comemora um TTFB baixíssimo que é só um cabeçalho de redirecionamento. Confira `%{http_code}` em toda coleta e use a URL final e canônica.
- **Comparar medições feitas de redes diferentes.** Do seu 4G, do escritório e de um servidor em outro país você terá três números distintos que não dizem nada sobre o servidor. Fixe o ponto de origem entre as duas coletas.
- **Trocar duas variáveis ao mesmo tempo.** Ligar o cache e atualizar o PHP no mesmo dia produz um ganho que você não sabe atribuir. Uma mudança, uma medição.

## Roteiro de poucos minutos antes de abrir chamado ou trocar de plano

- Rode o `curl-format.txt` uma vez e olhe a decomposição. Se DNS, TCP e TLS somam a maior parte, o assunto não é PHP.
- Colete 100 amostras com cache ligado e 100 com a query string aleatória. Compare as medianas.
- Se a diferença entre as duas medianas for grande, o custo está na geração da página. Cache de página resolve boa parte, e o resto é plugin, tema ou query.
- Se as duas medianas forem parecidas e altas, o cache não está pegando. Confira o cabeçalho de cache e se você não está medindo logado.
- Se as duas medianas forem baixas e o site continua parecendo lento, o gargalo está depois do primeiro byte. Aí é peso de página, e o curl já cumpriu o papel dele.

Esse roteiro leva alguns minutos e transforma "o site está lento" em uma frase que dá para agir: "o servidor gasta X ms gerando a home e Y ms entregando a versão cacheada". Com os dois números, a conversa com quem hospeda, com quem desenvolve o tema ou com você mesmo passa a ser sobre a causa, não sobre a sensação.

---

## Como medimos

100 requisições HTTPS à mesma página WordPress em um servidor LiteSpeed da Napoleon, feitas de um VPS externo: 50 aproveitando o cache de página (confirmado pelo cabeçalho x-litespeed-cache: hit) e 50 forçando a geração pelo PHP com uma query string única por requisição (x-litespeed-cache: miss). O TTFB de cada requisição foi medido com curl (time_starttransfer) e as medianas dos dois grupos foram comparadas: 115,6 ms com cache, 1.785,8 ms sem.
