# Como saber se seu site usa HTTP/2 com dois comandos curl

Dois comandos curl que devolvem a versão do protocolo por domínio, o loop para varrer a carteira inteira e por que vale checar TLS e ALPN antes de suspeitar de módulo desligado.

> rode `curl -o /dev/null -s -w "%{http_version}\n" https://seudominio.com.br`. A saída é `2` para HTTP/2, `1.1` para HTTP/1.1 ou `3` para HTTP/3. Um site leva dois segundos; um loop com a lista de domínios responde pela carteira em poucos minutos, ou menos se você paralelizar com `xargs -P`.

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

---

## Dois comandos que respondem a pergunta por domínio

O jeito mais rápido de saber a versão do protocolo de um domínio é pedir só o cabeçalho e forçar a negociação HTTP/2:

```bash
curl -I --http2 -s https://exemplo.com.br | head -n 1
```

Saída possível:

```
HTTP/2 200
```

Se vier `HTTP/1.1 200`, o servidor não negociou HTTP/2 naquela conexão. Atenção a um detalhe que confunde muita gente: `--http2` é uma oferta, não uma imposição. O curl anuncia suporte via ALPN no handshake TLS e aceita a resposta do servidor. Então o comando acima não "liga" HTTP/2, apenas revela se o outro lado aceita.

O segundo comando é o que serve para script, porque devolve só o número, sem cabeçalho para filtrar:

```bash
curl -o /dev/null -s -w "%{http_version}\n" https://exemplo.com.br
```

Saída: `2`, `1.1` ou `3`. Repare que aqui nem usei `--http2`: o curl moderno já oferece HTTP/2 por padrão em HTTPS. Use essa forma quando quiser saber o que o site **realmente** entrega a um cliente comum, e a forma com `--http2` quando quiser saber se o servidor é capaz de fazer HTTP/2 mesmo quando provocado.

### O que significam as saídas 2, 1.1, 3 e erro

| Saída de `%{http_version}` | O que significa na prática |
|---|---||
| `2` | Conexão negociada em HTTP/2 via ALPN |
| `1.1` | Servidor recusou ou não suporta HTTP/2 nessa conexão |
| `3` | Resposta veio em HTTP/3 (QUIC), comum atrás de CDN |
| `1.0` | Quase sempre um proxy ou appliance velho no caminho |

Se o domínio está atrás de Cloudflare ou de outra CDN, o que você mediu foi a borda da CDN, não o seu servidor. Para testar a origem, aponte o curl direto para o IP do servidor e mantenha o SNI correto:

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

O IP `203.0.113.10` acima é um exemplo de documentação, troque pelo IP real da hospedagem.

## Como varrer a carteira inteira e salvar o resultado em CSV

Quem cuida de 10 ou 50 sites não testa um por um. Monte um arquivo `dominios.txt` com um domínio por linha, sem `https://`, e rode:

```bash
while read -r d; do
  v=$(curl -o /dev/null -s -m 10 -w "%{http_version}" "https://$d")
  printf "%-35s %s\n" "$d" "${v:-erro}"
done < dominios.txt
```

Saída no formato (exemplo ilustrativo, não medição):

```
cliente-a.com.br                    2
cliente-b.com.br                    2
lojadocliente.com                   1.1
blog-antigo.com.br                  erro
```

O `-m 10` evita que um domínio morto trave a varredura. O `${v:-erro}` marca os casos em que o curl não conseguiu completar a conexão, que costumam ser DNS apontado para o lugar errado ou certificado vencido, e não problema de protocolo.

A varredura é sequencial: cada domínio custa o tempo da própria resposta e um domínio morto custa os 10 segundos inteiros do timeout, então 50 sites levam poucos minutos, não segundos. Com dezenas de domínios, rode em paralelo:

```bash
xargs -P 10 -I{} curl -o /dev/null -s -m 10 \
  -w "{} %{http_version}\n" "https://{}" < dominios.txt
```

Com `-P 10` a lista inteira termina no tempo do domínio mais lento vezes o número de lotes. A ordem da saída deixa de acompanhar a ordem do arquivo, por isso o domínio vai impresso na própria linha.

Para guardar histórico e comparar depois de uma migração, troque o `printf` por CSV:

```bash
while read -r d; do
  curl -o /dev/null -s -m 10 \
    -w "$d,%{http_version},%{http_code},%{time_total}\n" "https://$d" \
    || printf '%s,erro,,\n' "$d"
done < dominios.txt > protocolo-$(date +%F).csv
```

O `||` existe porque, quando o curl termina com status diferente de zero, ele não escreve a linha do `-w`: sem esse tratamento o domínio que falhou simplesmente some do arquivo e você acaba comparando listas de tamanhos diferentes antes e depois da migração.

Rodar isso antes e depois de qualquer mudança de servidor leva menos tempo do que abrir o DevTools em um único site.

## Por que o domínio cai para 1.1 mesmo com o módulo instalado

Esse é o pré-requisito que a maioria pula. Navegadores só negociam HTTP/2 sobre TLS, usando a extensão ALPN do handshake. Se o certificado está vencido, se o domínio responde em HTTPS com certificado de outro host, ou se o site redireciona tudo para `http://`, a negociação nem chega a acontecer e a conexão cai para HTTP/1.1. O módulo pode estar perfeitamente instalado no servidor.

Antes de mexer em qualquer configuração do Apache, cheque o TLS do domínio reprovado:

```bash
curl -sI https://lojadocliente.com | head -n 1
openssl s_client -connect lojadocliente.com:443 \
  -servername lojadocliente.com -alpn h2 </dev/null 2>/dev/null \
  | grep -i "ALPN"
```

Se o `openssl` responder `ALPN protocol: h2`, o servidor aceita HTTP/2 para aquele host. Se responder que não houve protocolo ALPN negociado, o problema está no TLS ou na configuração do vhost, e aí sim vale olhar o módulo.

Outras causas comuns de queda para 1.1 em ambiente compartilhado ou VPS com cPanel:

- Certificado emitido só para `www` e você testou o apex (ou o contrário).
- Proxy reverso ou firewall de aplicação na frente que fala só HTTP/1.1 com a origem.
- Teste feito em `http://` sem perceber o redirecionamento, o que devolve `1.1` legitimamente.
- Versão de curl antiga na sua máquina, sem suporte a HTTP/2. Confirme com `curl -V` e procure `HTTP2` na linha de features.

## Onde ativar o mod_http2 do EasyApache 4 no WHM

Na documentação do cPanel, o HTTP/2 do Apache é fornecido pelo módulo `ea-apache24-mod_http2`, instalado pelo EasyApache 4 ([docs.cpanel.net](https://docs.cpanel.net/ea4/apache/apache-modules/apache-module-http2/)). O caminho no WHM é o esperado: **WHM > Software > EasyApache 4**, personalizar o perfil, marcar o módulo na lista de Apache Modules e provisionar. O cPanel também documenta a instalação por linha de comando, com `yum install ea-apache24-mod_http2`, seguida do restart do Apache.

Depois do provisionamento, valide do lado de fora, não só pelo painel:

```bash
curl -I --http2 -s https://seudominio.com.br | head -n 1
```

Em servidores com LiteSpeed ou OpenLiteSpeed no lugar do Apache, o suporte a HTTP/2 vem embutido no próprio servidor web e não depende de módulo do EasyApache. Nesse cenário, se um domínio sai em 1.1, o caminho de investigação é o mesmo da seção anterior: certificado e vhost primeiro.

### Checklist de ativação para repetir em todo servidor

- Rodar o loop de varredura e separar a lista dos domínios em `1.1`.
- Para cada um, checar validade do certificado e o teste ALPN com `openssl`.
- Corrigir o SSL do que estiver quebrado e repetir o teste. Essa etapa vem antes porque o teste do openssl confirma ou elimina a causa em um comando.
- Só então verificar se o módulo HTTP/2 está presente no perfil do EasyApache.
- Provisionar, reiniciar o Apache e rodar a varredura de novo.
- Guardar o CSV do dia com a data, para ter o antes e o depois documentado.

## Quando HTTP/2 muda o tempo de carregamento e quando não muda

A promessa clássica do HTTP/2 é multiplexação: várias requisições em uma única conexão TCP, sem a fila de seis conexões paralelas por host do HTTP/1.1. O ganho é real quando existe fila. Em uma página com dezenas de CSS, JS e imagens servidos pelo mesmo domínio, a fila existe. Em uma landing enxuta, com dez requisições e CDN na frente, não existe fila para eliminar.

Para medir, pegue o tempo total de carregamento da página inteira, não só do HTML. O curl abaixo serve apenas como teste de sanidade: ele cronometra o documento HTML nos dois protocolos e confirma que a negociação está acontecendo como você espera.

```bash
# força HTTP/1.1
curl -o /dev/null -s --http1.1 -w "1.1 %{time_total}\n" https://exemplo.com.br
# deixa negociar HTTP/2
curl -o /dev/null -s --http2  -w "h2  %{time_total}\n" https://exemplo.com.br
```

Como mede só o documento HTML, a diferença entre as duas linhas tende a ser pouca ou nenhuma. A comparação de página completa vem de outro lugar: use a aba Network do navegador com cache desativado, ou o WebPageTest, e compare o tempo de carregamento completo em três execuções de cada lado. Três execuções é o mínimo: a variação entre uma e outra, em rede comum, costuma ser maior do que a diferença que você está tentando enxergar.

E aqui está o ponto que sustenta este texto: se o site tem poucos arquivos, já está atrás de uma CDN e com cache de página ativo, a diferença entre HTTP/1.1 e HTTP/2 desaparece dentro do ruído das medições. Não venda isso ao cliente como otimização de performance. Venda como higiene de infraestrutura, que é o que de fato é.

## O que medir junto para não atribuir o ganho ao protocolo errado

Quando você ativa HTTP/2, costuma mexer em outras coisas no mesmo dia: renovar certificado, ligar compressão, ajustar cache. Se medir só depois, atribui tudo ao protocolo. Separe:

| Item | Ferramenta de verificação | Resultado esperado |
|---|---|---||
| Versão do protocolo | `curl -w "%{http_version}"` | `2` |
| Compressão | `curl -IH 'Accept-Encoding: br, gzip'` | `content-encoding: br` ou `gzip` |
| Tempo até o primeiro byte | `curl -w "%{time_starttransfer}"` | comparar com o valor anterior |
| Handshake TLS | `curl -w "%{time_appconnect}"` | comparar com o valor anterior |
| Número de requisições no mesmo host | DevTools, aba Network | quanto maior, mais HTTP/2 importa |

Se o número de requisições no mesmo host for baixo, a última linha já diz que não espere ganho visível. Anote isso no relatório antes de fazer a mudança, não depois.

## A frase pronta para explicar a mudança ao cliente

Quando o cliente perguntar por que o site continua com a mesma sensação depois da mudança, use algo assim, por escrito, no mesmo e-mail em que você informa a conclusão do serviço:

> **** Ativamos o HTTP/2 no servidor do seu site. Ele é a versão mais recente do protocolo que o navegador usa para conversar com a hospedagem e permite baixar vários arquivos ao mesmo tempo em uma única conexão. O ganho de velocidade aparece em páginas com muitos arquivos. Como o seu site já é leve e usa CDN, a diferença percebida tende a ser pequena ou nenhuma. A mudança continua valendo: HTTP/2 é o padrão hoje e pré-requisito para otimizações futuras.

Essa frase faz três coisas ao mesmo tempo: entrega a informação técnica em linguagem de cliente, calibra a expectativa antes da reclamação chegar e justifica o trabalho sem prometer número que você não mediu. Guarde junto do CSV da varredura e você tem o serviço documentado de ponta a ponta.

