# Impressão Digital TLS (JA3/JA4): Por Que IPs Limpos Ainda São Bloqueados

Seu IP residencial está limpo, seus cabeçalhos estão perfeitos, e você ainda recebe um 403 na primeira solicitação. O problema está no seu handshake TLS — a impressão digital que os sistemas anti-bot leem antes de qualquer HTTP ser trocado.

Aqui está um enigma que todo scraper enfrenta eventualmente: o IP residencial está limpo, o User-Agent é uma string atual do Chrome, os cabeçalhos estão em perfeita ordem — e a primeira solicitação retorna `403`. Nada que você rotacione resolve isso. A razão é que o bloqueio ocorreu antes que seus cabeçalhos fossem lidos. Sistemas anti-bot modernos fazem a impressão digital do seu **handshake TLS**, e um cliente padrão de Python, Go ou curl se anuncia como um bot no ClientHello, uma camada abaixo do HTTP. É isso que a impressão digital JA3 e JA4 faz, e por que [curl recebe um 403 onde o navegador recebe um 200](https://quantumproxies.io/blog/curl-403-but-browser-works) na URL idêntica.

## O que a impressão digital TLS lê

Toda conexão HTTPS começa com um handshake TLS. O cliente envia um `ClientHello` que anuncia, em uma ordem específica, qual versão TLS deseja, quais conjuntos de cifras suporta, quais extensões oferece (SNI, ALPN, e mais), quais curvas elípticas e quais formatos de ponto. Nada disso nomeia diretamente seu navegador — mas a combinação e ordenação exata é uma assinatura quase única da pilha de software. A lista do Chrome difere da do Firefox, e ambas diferem muito de `requests` do Python ou `net/http` do Go. Leia o handshake, e você pode adivinhar o cliente antes de um byte de HTTP ser trocado.

## JA3: cinco campos em um hash MD5

JA3, publicado em 2017 por engenheiros da Salesforce, é o método clássico. Ele pega cinco campos do ClientHello — versão TLS, cifras, extensões, curvas elípticas e formatos de ponto — concatena-os e passa a string pelo MD5. Um exemplo concreto: os campos

```text
771,4865-4866-4867,0-11-10-35-16-5-13,29-23-24,0
```

geram o hash `e7d705a3286e19ea42f587b344ee6865` — uma impressão digital que pertence a uma compilação padrão do curl. Fornecedores anti-bot mantêm bancos de dados desses hashes. Uma solicitação cujo JA3 corresponde a uma biblioteca de raspagem conhecida recebe um limite de taxa mais rigoroso, um desafio ou um bloqueio total. A verificação mais poderosa é a correlação: se seu User-Agent afirma ser Chrome 120 mas seu JA3 diz `python-requests`, essa contradição por si só é suficiente para reprovar você.

## Por que o JA3 deu lugar ao JA4

JA3 tem uma fraqueza que o quebrou como um sinal estável. A partir do Chrome 110 e Firefox 114, os navegadores randomizam a ordem das extensões TLS em cada conexão para resistir à impressão digital. Isso significa que um navegador real agora produz um hash JA3 *diferente* a cada sessão — então o JA3 bruto gera falsos positivos em usuários genuínos. A resposta da indústria é **JA3N** (uma variante normalizada que ordena as extensões antes de fazer o hash, cancelando a randomização) e **JA4**, um esquema mais novo da FoxIO construído pelo próprio criador do JA3.

JA4 é mais legível e mais difícil de falsificar. Ele usa um layout de três partes `a_b_c`, por exemplo `t13d1516h2_8daaf6152771_e5627efa2ab1`. O prefixo por si só diz muito: `t` para TCP, `13` para TLS 1.3, `d` para um SNI baseado em domínio, `15` conjuntos de cifras, `16` extensões, e `h2` para HTTP/2 como o primeiro ALPN — seguido por dois hashes truncados das cifras ordenadas e das extensões mais algoritmos de assinatura. JA4 é um de uma família: JA4S faz a impressão digital do servidor, JA4H dos cabeçalhos HTTP, JA4X do certificado, e JA4T da camada TCP bruta.

![Dois clientes abrem um handshake TLS com o mesmo site: um cliente Python padrão é identificado por sua impressão digital JA3/JA4 e recebe um 403 antes que qualquer HTTP seja enviado, enquanto um cliente com formato de navegador passa pelo handshake e recebe um 200; o quadro mostra que os cabeçalhos só são lidos depois da verificação do handshake.](https://res.cloudinary.com/dmqliab0t/image/upload/f_auto,q_auto,w_1200/v1785335157/blog/generated/qp-b9-019-diag1.png)
*A consulta JA3/JA4 acontece no handshake — uma impressão digital incompatível é um 403 antes que seus cabeçalhos sejam lidos.*

## Por que um IP limpo não te salva

Esta é a parte que confunde pessoas que investem apenas em proxies. Um IP residencial impecável diz ao site que o tráfego vem de uma rede real. Um handshake TLS incompatível com o navegador diz que o tráfego vem de um script. Quando esses dois sinais discordam, o handshake vence, porque é muito mais difícil de falsificar por acidente. Você pode rotacionar por mil saídas limpas e ainda falhar em cada solicitação se todos os mil carregarem o mesmo JA3 `python-requests`. O IP e a impressão digital são eixos separados — você precisa acertar ambos.

Concretamente, isso aparece nas taxas de aprovação contra um alvo protegido por Cloudflare: um cliente padrão `requests` limpa cerca de dois por cento das solicitações, `httpx` com HTTP/2 faz um pouco melhor, e um cliente compatível com navegador ultrapassa os oitenta por cento. Mesmo pool de IP em todos os casos. A variável é a pilha TLS. A Akamai eleva ainda mais o nível combinando a impressão digital TLS com uma impressão digital HTTP/2 — os valores do quadro SETTINGS, tamanhos de janela e prioridades de fluxo — então mesmo um JA3 correto pode ser pego se a camada HTTP/2 parecer scriptada. Nossa análise de [por que a Akamai bloqueia a maioria do tráfego de proxy](https://quantumproxies.io/blog/why-akamai-bot-manager-blocks-most-proxy-traffic-in-2026) aprofunda-se nessa pilha.

![Taxas de aprovação contra um alvo protegido pela Cloudflare, com o mesmo pool de IPs limpos para todos os clientes: o python-requests padrão passa em cerca de 2%, o httpx com HTTP/2 um pouco mais, a automação de navegador headless em torno de sessenta por cento e um cliente curl_cffi igual a um navegador perto de oitenta e cinco por cento; o quadro diz que a solução é o handshake.](https://res.cloudinary.com/dmqliab0t/image/upload/f_auto,q_auto,w_1200/v1785335157/blog/generated/qp-b9-019-diag2.png)
*Mesmo IP limpo em todos os casos — apenas a pilha TLS muda a taxa de aprovação. A solução é o handshake, não a saída.*

## As opções de personificação que realmente passam

Você não pode anexar um handshake de navegador a um cliente padrão ajustando strings de cifras — os ajustes do OpenSSL e urllib3 simplesmente não expõem todos os parâmetros que o JA3 lê. O que funciona é um cliente que fala o dialeto TLS exato do navegador:

- **curl_cffi** (Python) — bindings sobre curl-impersonate. Um argumento, `impersonate="chrome120"`, e seu JA3 corresponde ao Chrome real.
- **curl-impersonate** — um binário curl modificado que reproduz as pilhas TLS e HTTP do Chrome e Firefox a partir da linha de comando.
- **tls-client** (Go) — um cliente HTTP com perfis de navegador selecionáveis (Chrome, Firefox, Safari) no nível do handshake.
- **Automação de navegador real** — Playwright, Puppeteer ou Selenium usam um motor de navegador real, então o JA3 é genuíno. O problema é que outros sinais (a flag `navigator.webdriver`, canvas e WebGL) ainda vazam, então as taxas de aprovação ficam em torno de sessenta por cento sem endurecimento extra.

```python
# curl_cffi: a browser-shaped handshake in two lines
from curl_cffi import requests

session = requests.Session(impersonate="chrome120")
r = session.get(
    "https://example.com",
    proxies={"https": "http://USER:PASS@residentialpremium.quantumproxies.io:8080"},
    timeout=20,
)
print(r.status_code)  # matched JA3 + a clean residential exit
```

Note o proxy nesse trecho. A personificação e uma saída limpa são complementares, não alternativas: o handshake em forma de navegador te faz passar na verificação TLS, e um [IP residencial limpo](https://quantumproxies.io/residential-proxies) mantém a solicitação fora das listas de bloqueio de reputação. Combine-os e você corrige ambos os eixos de uma vez.

[Pule a corrida armamentista TLS com a Scraper API](https://quantumproxies.io/scraper-api)

## Quando entregar todo o problema

A personificação DIY funciona até que o alvo rotacione sua detecção, adicione uma impressão digital HTTP/2 ou exija execução de JavaScript — então você está mantendo uma biblioteca de emulação de navegador como um segundo trabalho. Uma [Scraper API](https://quantumproxies.io/scraper-api) carrega uma impressão digital de navegador real e rotativa, corresponde à camada HTTP/2, executa JS sob demanda e retorna HTML limpo, markdown ou JSON de uma única chamada. Isso transforma a corrida armamentista TLS no problema de outra pessoa enquanto você continua com os dados. Para uma visão mais ampla de como os sites sinalizam automação, veja nosso guia sobre [todos os sinais de detecção de proxy](https://quantumproxies.io/blog/how-websites-detect-proxies).

## Perguntas frequentes

### O que é uma impressão digital JA3?

Uma impressão digital JA3 é um hash MD5 de cinco campos retirados do TLS ClientHello — versão TLS, conjuntos de cifras, extensões, curvas elípticas e formatos de ponto. Porque cada pilha de software ordena esses campos de maneira diferente, o hash identifica o cliente (Chrome, Firefox, curl, Python) antes de qualquer dado HTTP ser trocado.

### Qual é a diferença entre JA3 e JA4?

JA3 faz hash de cinco campos do ClientHello com MD5 e quebra quando os navegadores randomizam a ordem das extensões. JA4, da FoxIO, ordena os campos antes de fazer o hash para sobreviver a essa randomização, adiciona um prefixo de metadados legível por humanos e cobre QUIC/HTTP/3, ALPN e algoritmos de assinatura. JA4 é o sinal moderno mais confiável; JA3N é uma solução intermediária normalizada para o JA3.

### Posso contornar a impressão digital TLS apenas com proxies?

Não. Proxies mudam o IP, não o handshake. Se sua impressão digital TLS corresponder a uma biblioteca de raspagem conhecida, rotacionar saídas não ajudará — cada solicitação ainda carrega a assinatura do bot. Você precisa de um cliente que reproduza a pilha TLS de um navegador, depois um proxy limpo por cima para a reputação do IP.

### O Python requests tem uma impressão digital TLS detectável?

Sim. `requests` usa urllib3 com uma ordem de cifras e extensões distinta que os fornecedores anti-bot catalogaram, então seu JA3 é uma assinatura de bot conhecida. Mude para `curl_cffi` com um perfil `impersonate` para enviar um handshake compatível com navegador.

A impressão digital TLS moveu a luta para abaixo do HTTP, por isso truques de cabeçalho e rotação de IP deixaram de ser suficientes por si só. Combine o handshake, mantenha a saída limpa, e o problema de 403 na primeira solicitação desaparece. Este é um guia técnico, não uma licença para ignorar os termos de um site — sempre raspe dentro da lei e das regras do alvo.

[Deixe a Scraper API lidar com JA3, JA4 e HTTP/2](https://quantumproxies.io/scraper-api)