# Verificar gzip com curl: 464 KB viraram 58 KB

Do GET que revela o cabeçalho content-encoding até o critério por tipo de recurso: onde gzip resolve, onde brotli paga a CPU e por que JPEG e MP4 não ganham nada.

> um GET com `Accept-Encoding: gzip` responde em uma linha: se a resposta trouxer `content-encoding: gzip`, o servidor está comprimindo. No HTML de um WordPress em produção, isso foi 464 KB caindo para 58 KB, 8× menos bytes, 87% de redução.

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

---

## O comando que responde em uma linha

A verificação inteira cabe em um GET com o cabeçalho de negociação explícito:

```bash
curl -s -o /dev/null -D - -H 'Accept-Encoding: gzip, br' https://exemplo.com/ | grep -i -E 'content-encoding|content-length|vary'
```

Se voltar `content-encoding: gzip` (ou `br`), o servidor está comprimindo. Se não voltar nada, não está.

Dois detalhes que fazem a diferença entre um teste confiável e um falso negativo:

- **Não use `-I`.** `curl -I` manda um HEAD. Vários servidores e handlers de PHP não passam a resposta pelo filtro de compressão em HEAD, porque não há corpo para comprimir. Você lê "não comprime" e o site comprime. Use `-o /dev/null -D -`, que faz um GET real, joga o corpo fora e imprime só os cabeçalhos.
- **Não use `--compressed` quando o objetivo é medir bytes.** `--compressed` faz o curl anunciar os encodings suportados e descomprimir sozinho, o que embaralha a leitura de tamanho. Mandando o `Accept-Encoding` na mão, o curl entrega o corpo como ele veio no fio.

Para ver o antes e o depois em bytes, na mesma máquina, dois comandos:

```bash
# sem Accept-Encoding, curl não anuncia encoding e servidores como Nginx e
# Apache respondem identidade (a RFC 7231 5.3.4 permite qualquer coding
# nesse caso, então confira o cabeçalho da resposta antes de confiar)
curl -s -o /dev/null -w 'sem compressao: %{size_download} bytes\n' https://exemplo.com/

# com Accept-Encoding: gzip, sem --compressed, o curl não decodifica
curl -s -o /dev/null -H 'Accept-Encoding: gzip' \
     -w 'gzip:            %{size_download} bytes\n' https://exemplo.com/
```

`%{size_download}` conta os bytes do corpo. Sem `--compressed`, ele conta os bytes que trafegaram, não os bytes depois de descomprimir. É esse par de números que interessa. Se a primeira chamada vier com `content-encoding` mesmo sem você anunciar nada, o servidor está comprimindo por conta própria e a comparação de bytes perde o sentido: nesse caso force identidade com `-H 'Accept-Encoding: identity'`.

**8×** redução do peso do HTML de uma página WordPress real ao ativar compressão gzip nível 6 (464 KB sem compressão contra 58 KB comprimidos, 87% menos bytes) (n=100, setembro de 2026)

## O que 464 KB contra 58 KB significam no fio

O HTML de uma página WordPress em produção, servido sem `content-encoding`, tinha mediana de **cerca de 464 KB**. O mesmo HTML passado por `gzip -6` deu mediana de **cerca de 58 KB**. Oito vezes menos, 87% de redução, sem tocar em uma linha do tema, do plugin ou do banco.

Como os dois números saíram: 100 coletas da mesma URL em setembro de 2026, cada coleta lendo `%{size_download}` do curl, primeiro sem anunciar encoding e depois com `Accept-Encoding: gzip` e sem `--compressed`. Os dois valores da tabela são medianas das 100 coletas. Nível de compressão do lado do servidor: 6.

| Estado | Bytes do HTML (mediana de 100 coletas) | Relação |
|---|---|---||
| Sem `content-encoding` | ~464 KB | 1× |
| `gzip -6` | ~58 KB | 8× menos |

O ponto que costuma passar batido: HTML de WordPress é o material mais compressível que existe em uma resposta HTTP. É texto com repetição estrutural brutal, `<div class="...">` centenas de vezes, o mesmo prefixo de URL em cada `<link>` e cada `<script>`, atributos inline duplicados, JSON-LD com chaves repetidas. DEFLATE vive de repetição em janela de 32 KB. Quanto mais o tema empilha markup, mais o gzip encolhe.

A implicação prática é a que interessa a quem já otimizou latência. Se você já cortou TTFB, já matou o 301 extra e já resolveu handshake, o tempo restante do carregamento é dominado por bytes na rede. Em uma conexão de 5 Mbps reais, 464 KB de HTML são cerca de 0,76 s só de transferência do documento, antes de o parser sequer chegar aos assets. Os mesmos 58 KB são cerca de 0,10 s. E o HTML é o recurso que bloqueia a descoberta de todos os outros.

Uma coisa que **não** medi nesta janela: custo de CPU do servidor. Comparação de compressão em bytes é determinística e reproduzível em qualquer máquina. Tempo de compressão depende de CPU, de carga concorrente e da implementação (zlib clássica contra zlib-ng contra libdeflate). Por isso este artigo dá o comando para você medir CPU no seu hardware, e não um número inventado.

## Por que nível 6 e não 9

O nível do gzip vai de 1 a 9 e controla quanto esforço o algoritmo gasta procurando repetições. O ganho de bytes entre 6 e 9 é pequeno. O custo de CPU não é.

Meça no seu próprio HTML, que é o único que importa:

```bash
curl -s https://exemplo.com/ > pagina.html
wc -c < pagina.html

for n in 1 4 6 9; do
  printf 'gzip -%s: %s bytes\n' "$n" "$(gzip -$n -c pagina.html | wc -c)"
done
```

E o custo, no mesmo arquivo:

```bash
time (for i in $(seq 1 200); do gzip -6 -c pagina.html > /dev/null; done)
time (for i in $(seq 1 200); do gzip -9 -c pagina.html > /dev/null; done)
```

Rode isso e você vai ver por que 6 é o padrão de fato: é o joelho da curva. O nível 9 gasta CPU procurando casamentos marginais em conteúdo que já foi quase todo capturado no nível 6.

Há uma exceção clara: **conteúdo estático pré-comprimido**. Se o arquivo é comprimido uma vez, no deploy, e servido milhares de vezes, o custo de CPU acontece uma vez só. Aí vale `gzip -9` ou `brotli -q 11` em disco, com `gzip_static on;` e `brotli_static on;` no Nginx.

Outro detalhe: comprimir resposta minúscula piora. O container gzip tem 10 bytes de cabeçalho e 8 bytes de trailer, então uma resposta de 40 bytes pode sair maior do que entrou. Por isso existe `gzip_min_length`. Um limiar na casa de 1 KB é conservador e correto.

## Onde brotli paga a diferença de CPU

Brotli comprime melhor que gzip em texto por dois motivos estruturais: janela deslizante maior (até 16 MB contra 32 KB do DEFLATE) e um dicionário estático embutido com fragmentos comuns de HTML, CSS e JavaScript. Em um HTML pequeno, esse dicionário sozinho já dá vantagem, porque `<!DOCTYPE html>` e afins vêm de graça.

O problema é que `brotli -q 11` é lento o suficiente para ser um erro em conteúdo dinâmico. A regra que uso:

- **Conteúdo dinâmico** (HTML gerado por PHP a cada requisição, respostas de API, JSON): brotli em qualidade baixa, faixa de 4 a 5, ou gzip nível 6. Nessa faixa, brotli entrega compressão comparável ou melhor que gzip com custo de CPU parecido.
- **Conteúdo estático** (CSS, JS, SVG, fontes não comprimidas, JSON de build): brotli qualidade 11 gerado no deploy, servido de disco com `brotli_static`. Custo de CPU por requisição: zero.
- **Fallback obrigatório**: mantenha gzip ativo junto. Cliente que não anuncia `br` recebe `gzip`. A negociação é do cliente, não sua.

Compare no seu arquivo antes de decidir:

```bash
gzip -6   -c pagina.html | wc -c
brotli -q 5  -c pagina.html | wc -c
brotli -q 11 -c pagina.html | wc -c

time (for i in $(seq 1 200); do brotli -q 5  -c pagina.html > /dev/null; done)
time (for i in $(seq 1 200); do brotli -q 11 -c pagina.html > /dev/null; done)
```

Se a diferença de bytes entre `gzip -6` e `brotli -q 5` for de poucos por cento no seu HTML, e você não controla o build, gzip resolve. A diferença que justifica trabalho de infraestrutura aparece em bundles grandes de JS e CSS servidos estaticamente, onde `brotli -q 11` tem espaço para usar a janela grande.

Vale também saber que `zstd` já circula como `content-encoding` em navegadores recentes. É rápido e bom, mas o suporte no fio ainda é menos universal que gzip e brotli. Trate como terceiro encoding opcional, nunca como substituto do gzip.

## O que não comprime, e como confirmar em dez segundos

JPEG, PNG, GIF, WebP, AVIF, MP4, WebM, MP3, WOFF2 e arquivos ZIP já saem do codificador com a redundância removida. JPEG usa DCT com Huffman, PNG usa DEFLATE internamente, WOFF2 usa brotli internamente, MP4 carrega vídeo já codificado. Passar gzip por cima disso gasta CPU para produzir um arquivo do mesmo tamanho, às vezes um punhado de bytes maior por causa do cabeçalho e do trailer.

Não acredite em mim, teste com os seus próprios arquivos:

```bash
for f in foto.jpg logo.png banner.webp video.mp4 fonte.woff2; do
  printf '%-16s original: %8s  gzip -6: %8s\n' \
    "$f" "$(wc -c < "$f")" "$(gzip -6 -c "$f" | wc -c)"
done
```

Duas exceções que as pessoas erram com frequência, nos dois sentidos:

- **SVG comprime muito.** É XML. Deve estar na lista de tipos comprimidos como `image/svg+xml`. Um SVG de ícone servido sem compressão é desperdício puro.
- **WOFF e WOFF2 não devem ser recomprimidos.** WOFF2 já é brotli por dentro. Se a sua lista de `types` inclui `font/woff2`, tire.

O erro clássico de configuração é copiar uma lista de `gzip_types` da internet que inclui `image/jpeg` ou `video/mp4`. Isso não quebra nada visivelmente, apenas queima CPU em cada requisição de mídia sem devolver um byte.

## Critério de decisão por tipo de recurso

| Recurso | Comprimir | Encoding sugerido | Motivo |
|---|---|---|---||
| HTML dinâmico (WordPress, API) | Sim | gzip 6 ou brotli 4 a 5, on the fly | Alta redundância, custo de CPU aceitável por requisição |
| CSS e JS de build | Sim | brotli 11 e gzip 9 pré-gerados no deploy | Comprime uma vez, serve milhares de vezes |
| JSON de API | Sim | gzip 6 ou brotli 4 a 5 | Chaves repetidas comprimem muito bem |
| SVG | Sim | igual a CSS ou JS | É XML |
| XML, RSS, sitemap, `robots.txt` | Sim | gzip 6 | Texto |
| JPEG, PNG, GIF, WebP, AVIF | Não | identidade | Já entropicamente codificados |
| MP4, WebM, MP3 | Não | identidade | Já codificados, e streaming com range |
| WOFF2 | Não | identidade | Brotli por dentro |
| ZIP, gz, PDF já comprimido | Não | identidade | Sem redundância restante |
| Resposta abaixo de ~1 KB | Não | identidade | Overhead do container pode superar o ganho |

## Configuração mínima que funciona

### Nginx, gzip e brotli nas diretivas certas

```nginx
gzip on;
gzip_comp_level 6;
gzip_min_length 1024;
gzip_vary on;
gzip_proxied any;
gzip_types
    text/plain
    text/css
    text/xml
    text/javascript
    application/javascript
    application/json
    application/xml
    application/rss+xml
    image/svg+xml;
```

`text/html` é sempre comprimido pelo módulo e não entra em `gzip_types`. Se você listar, o Nginx avisa que é redundante. `gzip_proxied any` importa quando há um proxy ou CDN na frente: sem isso, respostas identificadas como vindas de proxy podem sair sem compressão.

Com o módulo `ngx_brotli` compilado:

```nginx
brotli on;
brotli_comp_level 5;
brotli_static on;
brotli_types text/css text/xml text/javascript
             application/javascript application/json
             application/xml application/rss+xml image/svg+xml;
```

### Apache com mod_deflate e mod_brotli

```apache
<IfModule mod_deflate.c>
  AddOutputFilterByType DEFLATE text/html text/plain text/css text/xml \
        text/javascript application/javascript application/json \
        application/xml application/rss+xml image/svg+xml
  DeflateCompressionLevel 6
</IfModule>

<IfModule mod_brotli.c>
  AddOutputFilterByType BROTLI_COMPRESS text/html text/css \
        application/javascript application/json image/svg+xml
  BrotliCompressionQuality 5
</IfModule>
```

Se `mod_brotli` e `mod_deflate` estiverem ativos para o mesmo tipo, o Apache escolhe conforme o `Accept-Encoding` e a ordem dos filtros. Teste a resposta real com o comando da primeira seção antes de considerar pronto.

### LiteSpeed e OpenLiteSpeed, onde a chave fica

No LiteSpeed a compressão é configuração de servidor, não de `.htaccess`. Gzip e brotli são ligados e ajustados na configuração do LSWS ou no painel que a expõe, com níveis separados para conteúdo dinâmico e estático e cache próprio de arquivos estáticos já comprimidos. Filtros de saída do `mod_deflate` colocados no `.htaccess` não são o mecanismo ali: mesmo que a linha não gere erro, quem decide se a resposta sai comprimida é o servidor. Em hospedagem compartilhada, procure a opção de compressão no painel. A verificação continua sendo a mesma: um GET com `Accept-Encoding` e leitura do cabeçalho de resposta.

### Quando o WordPress tenta comprimir sozinho

Plugins de cache oferecem compressão via PHP (`ob_gzhandler`, `zlib.output_compression`). Evite se o servidor já comprime. Compressão dupla não acontece, mas o PHP comprimindo é sempre mais caro que o servidor web comprimindo, e a combinação das duas camadas produz casos em que o `content-length` fica errado e a resposta chega truncada. Escolha uma camada, de preferência a de fora.

## Os quatro jeitos de a compressão sumir sem ninguém notar

### `Vary: Accept-Encoding` ausente

Sem esse cabeçalho, um proxy intermediário pode guardar a versão gzip e entregá-la a um cliente que não anunciou gzip, ou o contrário. No Nginx, `gzip_vary on;` resolve. Confira junto com o resto:

```bash
curl -s -o /dev/null -D - -H 'Accept-Encoding: gzip' https://exemplo.com/ \
  | grep -i -E 'content-encoding|vary'
```

### Proxy que remove o `Accept-Encoding`

Proxies corporativos e alguns balanceadores tiram o cabeçalho da requisição para inspecionar o conteúdo. O servidor de origem então responde sem comprimir, corretamente. Se você tem um proxy reverso na frente do Nginx, verifique se ele repassa o `Accept-Encoding` original ou se compensa comprimindo na saída.

### Compressão no estático e HTML de fora

É o caso mais comum em WordPress. O CSS e o JS vêm com `content-encoding: gzip` porque são servidos direto pelo Nginx, e o HTML vem sem, porque o passe para o PHP-FPM ignora o filtro ou porque o `location` do PHP está em outro bloco. Teste o HTML separadamente do asset:

```bash
for url in https://exemplo.com/ https://exemplo.com/wp-includes/js/wp-emoji-release.min.js; do
  printf '%s -> %s\n' "$url" \
    "$(curl -s -o /dev/null -D - -H 'Accept-Encoding: gzip, br' "$url" \
       | grep -i '^content-encoding' | tr -d '\r')"
done
```

### BREACH não justifica desligar a compressão do site

BREACH explora compressão em respostas HTTPS que misturam segredo (um token CSRF, por exemplo) com entrada refletida controlada pelo atacante, usando a variação do tamanho comprimido como oráculo. A reação de desligar a compressão do site inteiro custa 87% dos bytes do HTML para mitigar um ataque que exige condições bem específicas.

O caminho sensato é o mesmo que os frameworks adotaram: mascarar tokens CSRF por requisição (o mesmo segredo sai com bytes diferentes a cada resposta), não refletir entrada não sanitizada na mesma resposta que carrega segredo, e limitar taxa em endpoints que fazem eco de parâmetro. Compressão desligada em endpoints autenticados muito específicos é uma decisão defensável. Compressão desligada no site público inteiro não é.

## A verificação que entra no deploy

Depois de configurar, transforme a checagem em teste, não em memória:

```bash
#!/usr/bin/env bash
set -euo pipefail
URL="${1:?uso: $0 https://exemplo.com/}"

plano=$(curl -s -o /dev/null -H 'Accept-Encoding: identity' \
        -w '%{size_download}' "$URL")
comprimido=$(curl -s -o /dev/null -H 'Accept-Encoding: gzip, br' \
             -w '%{size_download}' "$URL")
enc=$(curl -s -o /dev/null -D - -H 'Accept-Encoding: gzip, br' "$URL" \
      | grep -i '^content-encoding' | tr -d '\r' || true)

echo "identidade : $plano bytes"
echo "negociado  : $comprimido bytes  ($enc)"

if [ -z "$enc" ]; then
  echo 'FALHA: servidor nao comprimiu' >&2
  exit 1
fi
```

Rode contra a home, contra uma página interna e contra um endpoint de API. Se algum dos três voltar sem `content-encoding`, você achou o buraco antes do usuário.

E guarde a ordem de prioridade. Ativar gzip nível 6 no HTML é a mudança de maior retorno por minuto de trabalho em um WordPress sem compressão: 464 KB viraram 58 KB no HTML que medi, sem tocar em código de aplicação. Brotli em qualidade 11 no estático vem depois, e vale o trabalho de pipeline. Comprimir JPEG e MP4 não vem nunca.

---

## Como medimos

100 requisições HTTPS à mesma página WordPress em produção confirmaram o tamanho servido sem compressão (mediana de 464.173 bytes, sem cabeçalho content-encoding). O mesmo HTML baixado foi comprimido com gzip nível 6, resultando em 57.635 bytes. A comparação é determinística: mesmo arquivo, com e sem compressão.
