---
title: "HTTP/1.1, HTTP/2 e HTTP/3: o que mudou em cada versão?"
description: "HTTP/1.1, HTTP/2 e HTTP/3 levam as mesmas requisições de jeitos diferentes: uma por vez, multiplexadas sobre TCP ou via QUIC em UDP. O que mudou e por quê."
url: https://proxynet.io/pt-br/blog/http-1-vs-http-2-vs-http-3
date: 2026-11-19
author: "Acar Diveroli"
category: "Comparativos, Redes"
lang: pt-BR
---

# HTTP/1.1, HTTP/2 e HTTP/3: o que mudou em cada versão?

Você abre as ferramentas do desenvolvedor do navegador numa página de produto lenta, adiciona a coluna `Protocol` e recarrega. A lista não concorda consigo mesma: a página e as imagens dizem `h3`, uma fonte de outro host diz `h2` e um script de rastreamento antigo diz `http/1.1`. Uma página, três versões do HTTP, todas carregando lado a lado.

Essa mistura é normal e diz muito sobre como a web funciona hoje. Este artigo explica o que cada versão (HTTP/1.1, HTTP/2 e HTTP/3) mudou, o que é o bloqueio de cabeça de fila e por que ele motivou duas versões novas, como o navegador escolhe a versão, como verificar qual versão um site usa e o que acontece com a versão quando seu tráfego passa por um proxy.

> **Nota: Resposta rápida**
>
> As três versões levam as mesmas requisições, métodos, códigos de status e cabeçalhos; a diferença está em como essas mensagens viajam. O HTTP/1.1 envia uma requisição por vez em cada conexão TCP, por isso os navegadores abrem várias conexões. O HTTP/2 divide cada requisição em quadros e multiplexa muitas delas numa única conexão TCP, com cabeçalhos comprimidos, mas um único pacote TCP perdido ainda trava todas. O HTTP/3 roda sobre QUIC em UDP, onde cada requisição tem seu próprio fluxo, então um pacote perdido segura só aquele fluxo; o QUIC também traz TLS 1.3 embutido e mantém a conexão viva quando sua rede muda. Os navegadores começam com HTTP/2 ou HTTP/1.1 e passam para o HTTP/3 quando o site o anuncia.

## O que as versões do HTTP têm em comum?

Todas as versões do HTTP falam a mesma língua; só muda o jeito de empacotar e enviar as palavras. Uma requisição `GET`, um status `404` ou um cabeçalho `Cache-Control` significam exatamente a mesma coisa nas três. Os padrões separam isso com clareza: o RFC 9110 define o significado comum, e um documento à parte para cada versão define como ele trafega na rede. Por isso uma aplicação web não precisa saber qual versão levou uma requisição, e por isso um servidor pode falar as três ao mesmo tempo.

## O que o HTTP/1.1 mudou?

O HTTP/1.1 tornou as conexões reutilizáveis. Como conta a [história do HTTP no MDN](https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/Evolution_of_HTTP), ele foi publicado pela primeira vez em janeiro de 1997, e sua maior mudança foi a **conexão persistente**: depois que uma resposta chega, a mesma conexão TCP continua aberta para a próxima requisição, em vez de ser fechada e refeita. Ele também tornou obrigatório o cabeçalho `Host`, o que permite que um único endereço IP atenda muitos sites.

O HTTP/1.1 é um protocolo de texto: uma requisição são linhas legíveis como `GET /index.html HTTP/1.1` seguidas de cabeçalhos. O limite é que uma conexão atende uma requisição por vez, e a próxima espera até a resposta anterior chegar inteira.

O **pipelining**, enviar várias requisições sem esperar as respostas, não resolveu isso, porque o servidor precisa devolver as respostas na ordem em que as requisições chegaram. Os navegadores contornaram o problema abrindo várias conexões paralelas por site, e os donos de sites juntaram arquivos em pacotes (bundles) e sprites de imagem.

## O que o HTTP/2 mudou?

O HTTP/2 permite que muitas requisições dividam uma conexão ao mesmo tempo. Padronizado em maio de 2015 e nascido do protocolo experimental SPDY, do Google, ele mantém o significado do HTTP, mas troca o formato de texto por um formato binário. A versão atual do padrão é o [RFC 9113](https://www.rfc-editor.org/rfc/rfc9113.html), de junho de 2022.

Quatro mudanças o definem:

1. **Enquadramento binário.** Cada requisição e resposta é cortada em quadros (frames) pequenos com estrutura fixa, que as máquinas processam com mais rapidez e confiabilidade do que linhas de texto.
1. **Fluxos e multiplexação.** Cada requisição ganha seu próprio fluxo (stream) numerado, e quadros de fluxos diferentes são intercalados numa única conexão TCP. Uma resposta lenta deixa de bloquear uma rápida no nível do HTTP.
1. **Compressão de cabeçalhos (HPACK).** Os navegadores enviam cabeçalhos quase idênticos em cada requisição, como cookies e o user agent. O HPACK mantém uma tabela dos cabeçalhos já enviados na conexão e troca as repetições por referências curtas.
1. **Server push.** O servidor podia enviar arquivos que o navegador ainda não tinha pedido. Na prática isso raramente ajudou, e o [anúncio do Chrome](https://developer.chrome.com/blog/removing-push) explica por que o push foi desativado por padrão no Chrome 106, com 103 Early Hints e preload como substitutos sugeridos.

No HTTPS, navegador e servidor combinam o HTTP/2 durante o handshake TLS, por meio de uma extensão chamada ALPN (Application-Layer Protocol Negotiation), usando o identificador `h2`. O padrão ainda permite HTTP/2 sem criptografia quando os dois lados sabem de antemão que o outro o fala, mas o antigo método de promover uma conexão HTTP/1.1 sem criptografia para HTTP/2 agora está obsoleto.

## O que é bloqueio de cabeça de fila?

Bloqueio de cabeça de fila (head-of-line blocking) é quando um item atrasado segura tudo o que está na fila atrás dele, como um carro parado no começo de uma estrada de pista única. Ele acontece em duas camadas diferentes, e cada nova versão do HTTP eliminou uma delas.

1. **No nível do HTTP (HTTP/1.1).** Uma conexão leva uma troca por vez. Se a primeira resposta é lenta, a segunda espera mesmo que esteja pronta; por isso os navegadores abriam conexões extras.
1. **No nível do TCP (HTTP/2).** O HTTP/2 elimina o primeiro problema, mas todos os seus fluxos dividem uma conexão TCP. O TCP entrega os bytes estritamente em ordem, então, quando um pacote se perde, tudo o que vem depois espera a retransmissão, inclusive dados de fluxos que não tinham nada a ver com o pacote perdido. O RFC 9113 diz claramente que o HTTP/2 não resolve o bloqueio de cabeça de fila do TCP.
1. **Sem fila compartilhada (HTTP/3).** O QUIC mantém a ordem dentro de cada fluxo, mas não entre fluxos, então um pacote perdido atrasa só o fluxo a que pertencia.

Na nossa máquina de teste, enviamos duas requisições juntas por uma conexão a um pequeno servidor Node.js local: uma resposta levava 2 segundos e a outra era instantânea. No HTTP/1.1, a resposta rápida chegou após 2.015 ms, presa atrás da lenta; no HTTP/2, chegou após 4 ms. O travamento no nível do TCP depende de perda de pacotes, por isso aparece em Wi-Fi fraco e em redes móveis, e não num teste local.

## O que o HTTP/3 mudou?

O HTTP/3 leva o HTTP do TCP para o QUIC, um protocolo de transporte que roda sobre UDP. O UDP envia pacotes sem garantia de entrega, então o QUIC acrescenta por cima sua própria confiabilidade e sua própria ordem, por fluxo e não para a conexão inteira; nossa [comparação entre TCP e UDP](/pt-br/blog/tcp-vs-udp) explica a diferença entre os dois protocolos de transporte.

O QUIC foi publicado como RFC 9000 em maio de 2021, e o HTTP/3 como [RFC 9114](https://www.rfc-editor.org/rfc/rfc9114.html) em junho de 2022. A mudança para o QUIC traz quatro diferenças práticas:

- **Fluxos independentes.** Cada requisição viaja em seu próprio fluxo QUIC. Um pacote perdido trava só o próprio fluxo; os outros continuam entregando.
- **Criptografia embutida.** O QUIC sempre usa TLS 1.3 e junta num só os handshakes de transporte e de criptografia. Uma conexão nova pode enviar a primeira requisição após uma viagem de ida e volta. Um cliente que retorna pode até enviar dados no primeiro pacote (0-RTT), que só deve levar requisições seguras de repetir, porque um atacante poderia reenviá-las.
- **Migração de conexão.** Uma conexão QUIC é identificada por IDs de conexão, não pelo seu endereço IP e pela sua porta. Quando seu celular passa do Wi-Fi para os dados móveis, a conexão pode continuar pelo novo caminho em vez de recomeçar.
- **QPACK em vez de HPACK.** O HPACK depende de que os cabeçalhos cheguem em ordem, o que o QUIC já não garante entre fluxos, por isso o HTTP/3 usa uma variante chamada QPACK.

O tráfego QUIC costuma usar a porta UDP 443. Alguns firewalls, filtros web de antivírus e roteadores antigos bloqueiam ou tratam mal o UDP nessa porta, e aí os navegadores voltam para o HTTP/2 sobre TCP. Quando essa volta falha no meio do caminho, o Chrome mostra um erro que explicamos no nosso artigo sobre [err_quic_protocol_error](/pt-br/blog/err-quic-protocol-error).

## HTTP/1.1, HTTP/2 e HTTP/3 lado a lado

| | HTTP/1.1 | HTTP/2 | HTTP/3 |
|---|---|---|---|
| Transporte | TCP | TCP | QUIC sobre UDP |
| Formato da mensagem | Texto | Quadros binários | Quadros binários |
| Requisições por conexão | Uma por vez | Muitas, multiplexadas | Muitas, fluxos independentes |
| Bloqueio de cabeça de fila | Nível HTTP e TCP | Nível TCP | Só dentro de um fluxo |
| Compressão de cabeçalhos | Nenhuma | HPACK | QPACK |
| Criptografia | Opcional (HTTPS) | TLS na prática | Sempre TLS 1.3 |
| Mudança de rede | Nova conexão | Nova conexão | A conexão migra |
| Padrão | RFC 9112 | RFC 9113 | RFC 9114 |

## Como o navegador escolhe a versão do HTTP?

O navegador negocia o HTTP/1.1 ou o HTTP/2 durante o handshake TLS e fica sabendo do HTTP/3 pelo próprio site. Na primeira mensagem do handshake, ele lista os protocolos que fala, como `h2` e `http/1.1`, e o servidor escolhe um.

O HTTP/3 não pode ser negociado assim, porque o navegador precisaria saber dele antes mesmo de abrir uma conexão TCP. Há duas formas de avisá-lo:

- **O cabeçalho Alt-Svc.** O servidor acrescenta a uma resposta comum um cabeçalho como `alt-svc: h3=":443"; ma=86400`, que quer dizer “o HTTP/3 está disponível na porta UDP 443; lembre-se disso por um dia”. O navegador tenta o QUIC nas requisições seguintes.
- **O registro DNS HTTPS.** Um tipo mais novo de registro DNS (RFC 9460) pode trazer `alpn=h3`, então o navegador fica sabendo do HTTP/3 enquanto ainda procura o endereço e pode usá-lo desde a primeira requisição.

Por isso a primeira requisição a um site muitas vezes mostra `h2` e as seguintes `h3`. A página do nosso exemplo inicial não está com defeito: cada host fez a própria escolha.

## Como verificar qual versão do HTTP um site usa?

As ferramentas do desenvolvedor do navegador mostram a versão de cada requisição. No Chrome ou no Edge:

1. Abra a página, pressione F12 (Cmd+Option+I no Mac) e selecione o painel `Network`.
1. Clique com o botão direito no cabeçalho da tabela de requisições e marque `Protocol`.
1. Recarregue a página. `http/1.1`, `h2` e `h3` correspondem às três versões.

No terminal, o `curl` pode informar a versão de uma única requisição:

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

O primeiro comando imprime `1.1`, `2` ou `3`; no segundo, uma linha `alt-svc` com `h3` significa que o site oferece HTTP/3. As versões que o curl consegue usar dependem de como ele foi compilado: `curl -V` as lista na linha **Features** como `HTTP2` e `HTTP3`.

Na nossa máquina de teste com Windows 11, isso fez diferença. O curl que vem com o Windows (8.22.0) não tem nenhum dos dois recursos, então `--http2` parou com `the installed libcurl version does not support this` e o primeiro comando imprimiu `1.1`. Mesmo assim, os cabeçalhos de `example.com` traziam `alt-svc: h3=":443"; ma=86400`, e uma conexão TLS do Node.js que ofereceu `h2` foi respondida com `h2`. O site oferece as três; o que você vê depende da ferramenta.

## O HTTP/3 é sempre mais rápido que o HTTP/2?

Não; o HTTP/3 ajuda mais onde a rede é ruim. Os ganhos vêm de menos viagens de ida e volta para abrir uma conexão, de nenhum travamento no nível do TCP quando pacotes se perdem e de conexões que sobrevivem a uma mudança de rede. Por isso aparecem em celulares que trocam de antena, em Wi-Fi lotado e em links de longa distância com perdas.

Numa linha cabeada estável, quase sem perdas, os dois costumam parecer iguais. Onde o UDP é bloqueado ou limitado, o navegador tenta o QUIC, desiste e volta atrás, o que custa tempo. Meça suas páginas nas redes que seus visitantes realmente usam.

## Qual versão do HTTP você recebe por meio de um proxy?

Na maioria dos proxies, você chega ao site com HTTP/2 ou HTTP/1.1, porque o túnel de proxy comum roda sobre TCP. Para um endereço `https://`, o cliente envia ao proxy uma requisição `CONNECT`, e o proxy abre uma conexão TCP com o site e repassa os bytes sem lê-los. O TLS e a versão do HTTP dentro dele são negociados diretamente entre o seu cliente e o site. Os nossos [Proxies HTTPS](https://proxynet.io/pt-br/https-proxy) funcionam assim, por túneis HTTP CONNECT.

O HTTP/3 precisa de UDP para chegar ao site, e um túnel TCP não consegue levá-lo. O RFC 9298 (2022) define o CONNECT-UDP, uma forma de tunelar UDP por um proxy HTTP. O SOCKS5 também pode repassar UDP, como fazem os nossos [Proxies SOCKS5](https://proxynet.io/pt-br/socks5-proxy) para apps que enviam UDP por conta própria.

Os navegadores não usam nenhum desses caminhos para páginas web hoje: a [documentação de proxy do Chromium](https://chromium.googlesource.com/chromium/src/+/HEAD/net/docs/proxy.md) observa que uma conexão com um proxy HTTPS pode negociar HTTP/2, mas não QUIC, e que o suporte a SOCKS5 do Chrome não repassa UDP.

Então ver `h2` por meio de um proxy quando a visita direta mostra `h3` é esperado, não é defeito. Se você está escolhendo entre protocolos de proxy por outros motivos, nosso [guia de proxy SOCKS e HTTP](/pt-br/blog/socks-vs-http-proxy) compara os dois.

## Onde você encontra as diferentes versões do HTTP

- **Navegação.** Muitos sites grandes e CDNs entregam HTTP/3 às versões atuais do Chrome, do Edge e do Firefox; outros param no HTTP/2.
- **APIs e ferramentas de linha de comando.** Muitas bibliotecas de cliente HTTP e muitos scripts ainda usam HTTP/1.1 por padrão.
- **Apps para celular.** Apps em redes instáveis são os que mais ganham com a migração de conexão do QUIC.
- **Proxies e redes corporativas.** Túneis e firewalls que só deixam passar TCP mantêm o tráfego no HTTP/2 ou no HTTP/1.1.

## Erros comuns

- **Achar que uma versão nova muda o significado de uma página.** Um `403` pelo HTTP/3 é o mesmo `403` que pelo HTTP/1.1.
- **Empacotar tudo para o HTTP/2.** Bundles gigantes e sprites eram gambiarras do HTTP/1.1; com a multiplexação, arquivos menores ficam melhores no cache.
- **Ativar o HTTP/3 sem abrir a UDP 443.** O `Alt-Svc` então anuncia uma porta que o firewall mantém fechada, e todo navegador precisa tentar e voltar atrás.
- **Desligar o QUIC de vez por causa de um erro.** É um teste útil, não uma configuração permanente.
- **Testar com um curl compilado sem HTTP/2.** O resultado diz `1.1` por causa da ferramenta, não do servidor.

## Guia de decisão

| Sua situação | O que fazer |
|---|---|
| Você mantém um site | Sirva HTTP/2 sobre TCP e acrescente HTTP/3 se seu servidor ou sua CDN suportar |
| Os visitantes usam sobretudo celular | Ative o HTTP/3 e mantenha a UDP 443 aberta |
| Um erro de HTTP/3 em uma rede específica | Teste com o QUIC desligado e depois corrija o firewall ou o filtro |
| Um cliente de API para scripts | HTTP/1.1 ou HTTP/2 basta para a maioria dos volumes de requisições |
| Você precisa ver qual versão recebeu | Coluna `Protocol` do DevTools ou `curl -w "%{http_version}"` |
| O tráfego passa por um proxy | Espere HTTP/2 ou HTTP/1.1 dentro de um túnel CONNECT |

## Perguntas frequentes

### O HTTP/3 é mais rápido que o HTTP/2?

Muitas vezes em redes móveis e com perdas; numa linha cabeada limpa, raramente por muito. Onde pouco se perde, os dois rendem mais ou menos igual, e um UDP bloqueado pode deixar o HTTP/3 mais lento por causa da volta atrás.

### O HTTP/2 exige HTTPS?

O padrão não exige, mas os navegadores negociam o HTTP/2 no handshake TLS, então na web ele chega por HTTPS. O HTTP/2 sem criptografia existe para casos em que os dois lados já sabem que o outro o suporta, como serviços conversando dentro de uma mesma rede. O HTTP/3 não tem nenhuma forma sem criptografia, porque o QUIC sempre usa TLS 1.3.

### O HTTP/1.1 ainda é usado?

Sim, e bastante. Muitas ferramentas de linha de comando, scripts, dispositivos embarcados e servidores antigos o usam, e túneis de proxy muitas vezes são abertos com uma requisição `CONNECT` em HTTP/1.1. Servidores web que oferecem HTTP/2 ou HTTP/3 normalmente continuam aceitando HTTP/1.1 para clientes que não conseguem usar nada mais novo.

### Qual é a diferença entre multiplexação e pipelining?

O pipelining (HTTP/1.1) envia várias requisições sem esperar, mas as respostas precisam voltar em ordem, então uma resposta lenta bloqueia as demais. A multiplexação (HTTP/2 e HTTP/3) corta requisições e respostas em quadros marcados com um número de fluxo e os intercala, então as respostas voltam na ordem em que ficam prontas.

### Devo desativar o QUIC ou o HTTP/3 no navegador?

Só para diagnosticar um problema. Se um site falha com um erro de QUIC em uma rede, desligar o QUIC para um teste mostra se o UDP é a causa; depois, corrija a causa e ligue de novo. Com o QUIC desligado, o navegador continua carregando todos os sites por HTTP/2 ou HTTP/1.1.

### Um servidor pode suportar HTTP/1.1, HTTP/2 e HTTP/3 ao mesmo tempo?

Sim, essa é a configuração comum de um site que oferece HTTP/3. O servidor escuta na porta TCP 443 para HTTP/1.1 e HTTP/2 e na porta UDP 443 para HTTP/3, e anuncia o HTTP/3 com um cabeçalho `Alt-Svc`. No nginx, por exemplo, o HTTP/3 vem de um módulo disponível desde a versão 1.25.0, que ainda é marcado como experimental e não é compilado por padrão.

## Em resumo

HTTP/1.1, HTTP/2 e HTTP/3 levam as mesmas requisições com o mesmo significado; o que mudou foi a entrega. O HTTP/1.1 atende uma requisição por vez em cada conexão, o HTTP/2 multiplexa muitas numa conexão TCP e o HTTP/3 passa para o QUIC em UDP, para que um pacote perdido trave só o próprio fluxo. Os navegadores escolhem a versão por host, e por isso uma página pode mostrar as três. Quando seu tráfego passa por um proxy, espere HTTP/2 ou HTTP/1.1 dentro do túnel e escolha o protocolo de que suas ferramentas precisam entre nossos [produtos de proxy](/pt-br/proxy).
