---
title: "Versão do ChromeDriver incompatível: como resolver o erro"
description: "This version of ChromeDriver only supports Chrome version N: esse erro indica que o Chrome atualizou e o driver não. Use o Selenium Manager ou fixe os dois."
url: https://proxynet.io/pt-br/blog/chromedriver-version-mismatch
date: 2026-10-06
author: "Acar Diveroli"
category: "Tutoriais, Web scraping"
lang: pt-BR
---

# Versão do ChromeDriver incompatível: como resolver o erro

Seu job do Selenium rodou sem problemas na sexta-feira. Na segunda, a primeira linha, `webdriver.Chrome()`, para com uma `SessionNotCreatedException` e duas linhas de texto: `This version of ChromeDriver only supports Chrome version 152` e `Current browser version is 154.0.8037.92`. Ninguém mexeu no código. O Chrome se atualizou sozinho no fim de semana, e o arquivo chromedriver no disco ficou como estava.

Este guia lê a mensagem, mostra a regra que o ChromeDriver aplica (tirada do código-fonte dele) e explica por que o erro agora volta a cada poucas semanas. Depois vêm as soluções: Selenium Manager, um driver desatualizado no `PATH`, Chrome for Testing, Docker e CI, o mesmo erro no Edge e um script em Python testado que aponta o driver desatualizado.

> **Nota: Resposta rápida**
>
> O ChromeDriver é compilado para uma única versão principal do Chrome. Ele abre o Chrome, lê a versão e para com "session not created" se o número principal for diferente, a menos que o navegador seja exatamente uma versão mais novo. O Chrome se atualiza sozinho e um chromedriver baixado não, então o erro aparece depois de uma atualização do navegador. No Selenium 4.6 ou posterior, remova o caminho do driver escrito no código e qualquer chromedriver antigo do `PATH` e chame `webdriver.Chrome()` para que o Selenium Manager baixe o driver correspondente. Quando toda execução precisar usar o mesmo navegador, fixe os dois com o Chrome for Testing.

## O que significa "This version of ChromeDriver only supports Chrome version"?

O ChromeDriver é um pequeno programa entre o Selenium e o Chrome: o Selenium envia a ele comandos WebDriver padrão, como "abra esta URL", e o ChromeDriver os transforma em comandos que o Chrome entende. Cada build sai do mesmo código-fonte de uma versão do Chrome e carrega o número dessa versão.

Uma sessão é um navegador que o seu código controla até `quit()`; "session not created" significa que nem se chegou a esse ponto. Foi isto que o Selenium 4.50 mostrou no nosso teste com o ChromeDriver 152 e um build de teste do Chrome 154 (caminho encurtado, stack trace cortado):

```text
selenium.common.exceptions.SessionNotCreatedException: Message: session not created: This version of ChromeDriver only supports Chrome version 152
Current browser version is 154.0.8037.92 with binary path ...\154.0.8037.92\chrome-win64\chrome.exe; For documentation on this error, please visit: https://www.selenium.dev/documentation/webdriver/troubleshooting/errors#sessionnotcreatedexception
```

A mensagem tem três partes:

- **`only supports Chrome version 152`** é a versão principal do driver que o Selenium iniciou.
- **`Current browser version is 154.0.8037.92`** é a versão completa do Chrome que esse driver abriu.
- **`with binary path`** indica o arquivo do Chrome. Numa máquina com Chrome, Chrome Beta e um build de teste, ele mostra qual foi escolhido.

O texto vem do próprio ChromeDriver, não do pacote Python, por isso Java, C# e JavaScript mostram as mesmas duas linhas dentro da própria exceção. O stack trace (a lista de chamadas que levou ao erro) logo abaixo pertence ao driver e não acrescenta nada aqui.

## Quais versões do Chrome um ChromeDriver aceita?

A verificação é uma função curta, `CheckVersion`, no [código-fonte do inicializador do ChromeDriver](https://chromium.googlesource.com/chromium/src/+/refs/heads/main/chrome/test/chromedriver/chrome_launcher.cc). Ela compara só o primeiro número das duas versões:

1. **Mesma versão principal:** a sessão começa.
2. **Chrome exatamente uma versão principal mais novo que o driver:** a sessão começa, e o driver grava um aviso no log. Um comentário no código explica o motivo: um driver Beta deve conseguir controlar um navegador Dev ou Canary.
3. **Qualquer outro caso**, inclusive um Chrome *mais antigo* que o driver: `session not created`.

Testamos cada caso com builds do Chrome for Testing, Selenium 4.50.0 e Python 3.13 no Windows 11:

| ChromeDriver | Chrome | Resultado |
|---|---|---|
| 154.0.8037.92 | 154.0.8037.92 | A sessão começa |
| 153.0.8010.52 | 154.0.8037.92 | A sessão começa, aviso só no log do driver |
| 152.0.7977.82 | 154.0.8037.92 | `session not created` |
| 154.0.8037.92 | 153.0.8010.52 | `session not created` (driver mais novo que o navegador) |

Na segunda linha, o log do driver dizia `This version of ChromeDriver has not been tested with Chrome version 154.` O Selenium esconde esse log a menos que você peça, então o aviso passa despercebido até a próxima versão do Chrome transformá-lo em erro. A documentação do ChromeDriver do Google é mais rígida que o código e pede que os números principal, secundário e de build coincidam.

## Por que o erro volta sempre?

O Chrome se atualiza sozinho: a nova versão é baixada em segundo plano e passa a valer na próxima vez que o navegador abre, e o Selenium inicia um Chrome novo a cada sessão. Já um chromedriver que você baixou é um arquivo executável comum, e nada o atualiza.

Desde o Chrome 153 isso acontece com mais frequência. O Google [passou o Chrome para um ciclo estável de duas semanas](https://developer.chrome.com/blog/chrome-two-week-start) em 8 de setembro de 2026 no desktop, no Android e no iOS: o Chrome 154 saiu em 22 de setembro, o 155 em 6 de outubro, e o 156 está previsto para 20 de outubro. Com a folga de uma versão, um driver que combinava com o Chrome no dia do lançamento sobrevive a uma versão e falha na seguinte; a vida útil dele agora é de cerca de quatro semanas, e não mais oito. Empresas no canal Extended Stable continuam recebendo uma nova versão principal só a cada oito semanas.

Para ver os dois números, abra o Chrome e selecione **Mais** > **Ajuda** > **Sobre o Google Chrome**. Para o driver, execute-o com `--version`:

```text
> chromedriver --version
ChromeDriver 152.0.7977.82 (d04cdb24d67b081f6cf80200ffc5233f44b61109-refs/branch-heads/7977@{#2322})
```

## Como o Selenium escolhe qual chromedriver iniciar?

A maioria dos casos de "ontem funcionava" se resume a qual arquivo de driver o Selenium escolheu. Com o Selenium 4.50, `webdriver.Chrome()` procurou nesta ordem:

1. **Um caminho passado em `Service(executable_path=...)`.** O Selenium usa esse arquivo como está e nunca verifica a versão dele.
2. **Um `chromedriver` no `PATH`**, a lista de pastas onde o sistema procura programas. O Selenium Manager usa essa cópia mesmo quando as versões não batem e só mostra um aviso.
3. **Um driver baixado pelo Selenium Manager.** Ele lê a versão do Chrome que vai abrir, procura o driver correspondente no Chrome for Testing e o guarda em `~/.cache/selenium`.

O Selenium Manager é um programa auxiliar que vem dentro de todo pacote oficial do Selenium desde a versão 4.6, por isso se comporta igual em Python, Java, C#, Ruby e JavaScript. A [documentação do Selenium Manager](https://www.selenium.dev/documentation/selenium_manager/) lista as configurações dele; cada uma tem também uma variável de ambiente que começa com `SE_`.

## Solução 1: remova o caminho fixo do driver

Tutoriais antigos baixam o ChromeDriver à mão e passam a localização dele. Esse caminho deixa de bater com a próxima atualização do Chrome:

```python
from selenium import webdriver
from selenium.webdriver.chrome.service import Service

# Antes: um arquivo fixo que fica desatualizado depois de uma atualização do Chrome
service = Service(executable_path=r"C:\tools\chromedriver.exe")
driver = webdriver.Chrome(service=service)

# Depois: sem caminho, o Selenium Manager busca o driver para o Chrome instalado
driver = webdriver.Chrome()
```

Verifique primeiro a versão instalada com `pip show selenium`: qualquer versão anterior à 4.6 não tem o Selenium Manager, e a versão atual, a 4.50.0, saiu em 30 de setembro de 2026. No nosso teste, a segunda forma baixou o ChromeDriver 154.0.8037.92 para o Chrome 154.0.8037.92 na primeira execução e o reutilizou depois.

O download precisa de acesso à internet. Atrás de um proxy corporativo, coloque o endereço do proxy em `SE_PROXY`; numa máquina sem nenhum acesso à internet, forneça você mesmo os dois arquivos, como na solução 3. Os drivers para o Chrome 115 e posteriores só são publicados no Chrome for Testing, por isso um script de download antigo que lê o antigo site de armazenamento do ChromeDriver para na versão 114.

## Solução 2: apague o chromedriver antigo do PATH

O Selenium Manager não resolve este caso sozinho. Se um `chromedriver.exe` antigo estiver numa pasta do `PATH`, como uma pasta de ferramentas ou a pasta `Scripts` do Python, o Selenium Manager o usa e só avisa. Com o ChromeDriver 152 no `PATH` e o Chrome 154, nossa execução mostrou esta linha antes da exceção:

```text
The chromedriver version (152.0.7977.82) detected in PATH at ...\chromedriver.exe might not be compatible with the detected chrome version (154.0.8037.92); currently, chromedriver 154.0.8037.92 is recommended for chrome 154.*, so it is advised to delete the driver in PATH and retry
```

Encontre todas as cópias com `where.exe chromedriver` no Windows ou `which -a chromedriver` no macOS e no Linux e depois apague o arquivo ou tire a pasta dele do `PATH`. Se você não pode alterar a máquina, como num servidor de build compartilhado, defina `SE_SKIP_DRIVER_IN_PATH=true`. No nosso teste, o Selenium Manager passou então a ignorar a cópia desatualizada, baixou o driver 154 e a sessão começou.

## Solução 3: fixe o Chrome e o ChromeDriver com o Chrome for Testing

As soluções 1 e 2 acompanham o Chrome instalado, o que serve para uma máquina de desenvolvimento. Jobs agendados e suítes de teste muitas vezes precisam do contrário: o mesmo navegador em toda execução, atualizado quando você decidir. O [Chrome for Testing](https://googlechromelabs.github.io/chrome-for-testing/) é um build do Chrome feito para isso. Ele não se atualiza sozinho, e cada versão é publicada junto com o ChromeDriver do mesmo número. Com o Selenium Manager, fixar a versão exige uma única opção:

```python
from selenium import webdriver

options = webdriver.ChromeOptions()
options.browser_version = "153"  # Chrome for Testing 153 e ChromeDriver 153
driver = webdriver.Chrome(options=options)
print(driver.capabilities["browserVersion"])  # 153.0.8010.52 no nosso teste
driver.quit()
```

Se o Chrome instalado tiver outra versão principal, o Selenium Manager baixa o Chrome for Testing 153 para o cache, ao lado do driver; se o Chrome instalado já for o 153, ele usa esse. `SE_FORCE_BROWSER_DOWNLOAD=true` faz com que ele use sempre o build baixado, e `SE_CACHE_PATH` muda o cache de lugar, por exemplo para a pasta do projeto.

Para uma máquina offline ou uma imagem Docker, baixe os arquivos compactados do navegador e do driver na mesma linha de versão do painel do Chrome for Testing e aponte o Selenium para eles com `options.binary_location` e `Service(executable_path=...)`. Aqui um caminho fixo não é problema, porque o navegador ao lado não consegue se atualizar.

## webdriver-manager, Docker e CI

Projetos Python mais antigos chamam `ChromeDriverManager().install()` do pacote `webdriver-manager`, cujo README agora recomenda o Selenium Manager para o Selenium 4.6+. Esse pacote guarda os drivers em cache numa pasta `.wdm` por um dia, por padrão, e `driver_version="..."` congela o driver enquanto o Chrome avança. Remova esse argumento ou troque a chamada pela solução 1.

Contêineres e servidores de build costumam quebrar depois de uma reconstrução da imagem:

- **Um Dockerfile com o Chrome atual e um driver fixo.** `apt-get install google-chrome-stable` instala o que estiver atual no dia do build, enquanto um chromedriver baixado de uma URL com número de versão fica parado. Instale os dois a partir de uma mesma versão do Chrome for Testing ou deixe o Selenium Manager buscar o driver em tempo de execução.
- **As imagens Docker do Selenium.** As tags de `selenium/standalone-chrome` trazem as duas versões, por exemplo `153.0-chromedriver-153.0-20260909`, então navegador e driver combinam dentro da imagem. O projeto recomenda uma tag completa em vez de `latest`.
- **Runners hospedados pelo GitHub.** As imagens Ubuntu trazem o Chrome com um ChromeDriver compatível, com link em `/usr/bin`, que está no `PATH`. Se um passo do workflow instalar outro Chrome, esse driver deixa de combinar; defina `SE_SKIP_DRIVER_IN_PATH=true` ou instale o driver da mesma fonte que o navegador.

## O mesmo erro no Edge e por que o Playwright o evita

O Edge é baseado no Chromium, e o driver dele, o msedgedriver (Microsoft Edge WebDriver), falha do mesmo jeito depois de uma atualização do Edge: `This version of Microsoft Edge WebDriver only supports Microsoft Edge version 122`, seguido de `Current browser version is 124.0.2478.80`. A [documentação do WebDriver da Microsoft](https://learn.microsoft.com/en-us/microsoft-edge/webdriver/) pede um driver cujas três primeiras partes da versão coincidam com as do Edge; o Edge mostra a versão em `edge://settings/help`. As soluções valem do mesmo jeito: o Selenium Manager baixa o msedgedriver para `webdriver.Edge()`, e uma cópia antiga no `PATH` atrapalha exatamente como um chromedriver antigo.

O Playwright evita o problema já na concepção. Cada versão do Playwright está ligada a builds específicos dos navegadores, que o `playwright install` baixa, então não há um arquivo de driver separado para manter em sintonia com o navegador. A falha equivalente nele é "Executable doesn't exist" depois de atualizar a biblioteca, resolvida rodando `playwright install` de novo. Se o ciclo de duas semanas do Chrome faz você repensar a ferramenta, nossa [comparação entre Playwright e Selenium](/pt-br/blog/playwright-vs-selenium) executa a mesma tarefa nos dois.

## Um script em Python que aponta o driver desatualizado

O script inicia o Chrome do jeito que a solução 1 recomenda e transforma uma incompatibilidade de versões em duas linhas que dizem qual arquivo remover. Ele lê as duas versões principais na mensagem, verifica se foi usado um chromedriver do `PATH` e relança sem alterações qualquer outro erro `session not created`.

```python
"""Inicia o Chrome com o Selenium e explica uma incompatibilidade de versão entre driver e navegador."""
import os
import re
import shutil
import sys

from selenium import webdriver
from selenium.common.exceptions import SessionNotCreatedException
from selenium.webdriver.chrome.service import Service

MISMATCH = re.compile(
    r"only supports Chrome version (?P<driver>\d+)\s+"
    r"Current browser version is (?P<browser>\d+)"
)

def start_chrome(browser_version=None, binary=None, driver_path=None, headless=True):
    """Retorna um driver do Chrome; se as versões não baterem, diz qual driver está desatualizado e encerra."""
    options = webdriver.ChromeOptions()
    if browser_version:  # ex.: "154": o Selenium Manager busca esse Chrome for Testing e o driver dele
        options.browser_version = browser_version
    if binary:  # um build do Chrome for Testing que você mesmo descompactou
        options.binary_location = binary
    if headless:
        options.add_argument("--headless")
    service = Service(executable_path=driver_path) if driver_path else None

    try:
        driver = webdriver.Chrome(options=options, service=service)
    except SessionNotCreatedException as exc:
        found = MISMATCH.search(exc.msg or "")
        if not found:
            raise  # "session not created" por outro motivo: leia a mensagem completa
        print(f"ChromeDriver {found['driver']} cannot drive Chrome {found['browser']}.")
        on_path = shutil.which("chromedriver")
        if driver_path:
            print(f"The fixed path is stale: {driver_path}")
            print("Remove driver_path and let Selenium Manager pick the driver.")
        elif on_path:
            print(f"Selenium used the chromedriver on PATH: {on_path}")
            print("Delete that file (or set SE_SKIP_DRIVER_IN_PATH=true) and run again.")
        sys.exit(1)

    caps = driver.capabilities
    driver_version = caps["chrome"]["chromedriverVersion"].split(" ")[0]
    print(f"Chrome {caps['browserVersion']} with ChromeDriver {driver_version}")
    return driver

if __name__ == "__main__":
    driver = start_chrome(
        browser_version=os.environ.get("CHROME_VERSION"),
        binary=os.environ.get("CHROME_BINARY"),
        driver_path=os.environ.get("CHROMEDRIVER_PATH"),
    )
    try:
        driver.get("https://example.com/")
        print(driver.title)
    finally:
        driver.quit()
```

O script só precisa de `pip install selenium`; sem variáveis de ambiente, ele inicia o Chrome instalado. Deixamos em inglês as mensagens que o script imprime, para que batam com a saída real abaixo.

### Como fica a saída

Rodamos o script cinco vezes no Windows 11 com o Selenium 4.50.0, o Chrome for Testing 154 em `CHROME_BINARY` (execuções 1, 2, 3 e 5) e o cache do Selenium Manager na pasta do projeto. As linhas que começam com `#` são nossos rótulos; os caminhos foram encurtados:

```text
# 1. ChromeDriver 152 on PATH
The chromedriver version (152.0.7977.82) detected in PATH at ...\chromedriver.exe might not be compatible with the detected chrome version (154.0.8037.92); currently, chromedriver 154.0.8037.92 is recommended for chrome 154.*, so it is advised to delete the driver in PATH and retry
ChromeDriver 152 cannot drive Chrome 154.
Selenium used the chromedriver on PATH: ...\152.0.7977.82\chromedriver-win64\chromedriver.EXE
Delete that file (or set SE_SKIP_DRIVER_IN_PATH=true) and run again.

# 2. CHROMEDRIVER_PATH set to ChromeDriver 152
ChromeDriver 152 cannot drive Chrome 154.
The fixed path is stale: ...\152.0.7977.82\chromedriver-win64\chromedriver.exe
Remove driver_path and let Selenium Manager pick the driver.

# 3. No driver anywhere: Selenium Manager downloads 154
Chrome 154.0.8037.92 with ChromeDriver 154.0.8037.92
Example Domain

# 4. CHROME_VERSION=153 (with SE_FORCE_BROWSER_DOWNLOAD=true)
Chrome 153.0.8010.52 with ChromeDriver 153.0.8010.52
Example Domain

# 5. Run 1 again with SE_SKIP_DRIVER_IN_PATH=true
Chrome 154.0.8037.92 with ChromeDriver 154.0.8037.92
Example Domain
```

A primeira linha da execução 1 é o aviso do próprio Selenium Manager, impresso pelo módulo `logging` do Python.

## Outras mensagens de "session not created"

Nem todo `session not created` tem a ver com versões. Outros dois apareceram durante os nossos testes, e o script os repassa sem alterações:

| Mensagem depois de "session not created" | O que aconteceu | O que verificar |
|---|---|---|
| `from unknown error: no chrome binary at ...` | `binary_location` aponta para um arquivo que não existe | O caminho em `options.binary_location` |
| `Chrome failed to start: crashed.` com `DevToolsActivePort file doesn't exist` | O Chrome fechou logo depois de abrir; aqui, outra sessão usava a mesma pasta de perfil | Um `--user-data-dir` por sessão, ou nenhum |

## Onde esse erro aparece

- **Scrapers e monitoramento de preços agendados** que rodam sem supervisão: a primeira execução depois de uma atualização do Chrome falha antes de carregar qualquer página.
- **Suítes de teste em notebooks de desenvolvedores** com um driver de um guia de instalação antigo ainda no `PATH`.
- **Pipelines de CI** depois que muda a imagem do runner ou a imagem base do Docker.
- **Servidores compartilhados** onde alguém instalou o chromedriver para todo mundo anos atrás.

A verificação de versão acontece antes de o Chrome carregar uma única página, então a rede nunca é a causa. Um scraper que usa os [Proxies de datacenter](https://proxynet.io/pt-br/datacenter-proxy) falha do mesmo jeito que um numa conexão doméstica, e trocar de proxy não muda nada.

## Erros comuns

- **Fixar de novo no código o caminho de um driver recém-baixado.** Funciona até o Chrome avançar duas versões, hoje cerca de quatro semanas.
- **Atualizar a cópia errada.** Um driver mais novo numa pasta não ajuda enquanto um mais antigo estiver antes no `PATH`.
- **Fazer downgrade do Chrome do dia a dia para combinar com um driver antigo.** Você abre mão das correções de segurança; para um navegador mais antigo, use o Chrome for Testing.
- **Contar com a folga de uma versão.** O aviso vai parar num log que ninguém lê.
- **Adicionar `--disable-build-check` ao ChromeDriver.** Essa opção sem suporte pula a comparação e faz o driver avisar que bugs vistos só com ela não devem ser relatados. Ela esconde a incompatibilidade em vez de corrigi-la.

## Guia de decisão

| O que você vê | O que fazer |
|---|---|
| Versão principal do driver duas ou mais abaixo do Chrome | Remova o caminho fixo; deixe o Selenium Manager escolher o driver |
| Aviso do Selenium Manager sobre um driver no PATH | Apague esse arquivo ou defina `SE_SKIP_DRIVER_IN_PATH=true` |
| Driver mais novo que o Chrome | Atualize o Chrome em Sobre o Google Chrome ou fixe com `browser_version` |
| Os testes precisam rodar no mesmo navegador por semanas | Fixe o Chrome e o ChromeDriver com o Chrome for Testing |
| Erro depois de reconstruir a imagem Docker | Instale os dois de uma mesma versão do Chrome for Testing ou use uma imagem do Selenium com tag completa |
| Selenium anterior à 4.6 | Atualize o Selenium |
| A mesma mensagem no msedgedriver | Os mesmos passos com `webdriver.Edge()`; confira `edge://settings/help` |

## Perguntas frequentes

### Por que o ChromeDriver parou de funcionar se eu não mudei nada?

O Chrome se atualizou sozinho e aplicou a atualização na próxima vez que abriu, enquanto o arquivo chromedriver ficou na versão antiga. Quando o navegador fica duas versões principais à frente, ou o driver é mais novo que o navegador, a sessão é recusada.

### O ChromeDriver 153 consegue controlar o Chrome 154?

Sim, com um aviso no log do driver; no nosso teste a sessão começou normalmente. O ChromeDriver 153 recusa o Chrome 155 e qualquer versão anterior à 153.

### Onde o Selenium Manager salva os drivers que baixa?

Em `~/.cache/selenium`, na sua pasta pessoal, organizados por driver, plataforma e versão, junto com os builds do Chrome for Testing que ele tenha baixado. Defina `SE_CACHE_PATH` para manter o cache numa pasta do projeto.

### Devo impedir que o Chrome se atualize para o driver continuar compatível?

Não no navegador que você usa todo dia, porque as atualizações trazem correções de segurança. Para testes que não podem mudar, use o Chrome for Testing: ele nunca se atualiza sozinho, e você decide quando passar para uma versão mais nova.

### Um proxy pode causar "session not created"?

Não. O ChromeDriver compara as versões antes de o Chrome abrir qualquer página, e o argumento `--proxy-server` só afeta o tráfego depois disso. Um proxy corporativo pode, porém, bloquear o download do Selenium Manager; defina `SE_PROXY` para que o download passe por ele.

### A mesma solução funciona em Java, C# e JavaScript?

Sim. O Selenium Manager vem com todo pacote oficial do Selenium desde a 4.6: em Java, remova `System.setProperty("webdriver.chrome.driver", ...)`; em C# e JavaScript, pare de passar um caminho de driver.

## Em resumo

"This version of ChromeDriver only supports Chrome version N" significa que o Chrome se atualizou sozinho e o arquivo do driver não. O ChromeDriver aceita a mesma versão principal e, com um aviso, uma versão mais nova; por isso, no ciclo de duas semanas do Chrome, um driver congelado dura cerca de quatro semanas. Remova os caminhos fixos de driver e as cópias antigas do `PATH`, deixe o Selenium Manager escolher o driver correspondente e fixe os dois com o Chrome for Testing onde as execuções precisam ser idênticas.

Quando a sessão voltar a iniciar, o próximo passo na maioria dos jobs de scraping é a configuração de rede; nosso guia de [como usar proxy com o Selenium](/pt-br/blog/selenium) cobre Chrome, Edge, autenticação e SOCKS5.

Para sites que avaliam os visitantes pela reputação do endereço IP, envie esse tráfego pelos [Proxies residenciais](https://proxynet.io/pt-br/residential-proxy), que saem por conexões residenciais.