AdsPower vs ClonBrowser: Qual Navegador Anti-Detecção Vence?
18 de nov. de 2026
O AdsPower dá a cada perfil de navegador uma impressão digital isolada, e o Selenium fornece o código que controla um navegador. Juntos, você pode automatizar dezenas de contas que parecem dispositivos reais separados. Este guia explica como as duas ferramentas se conectam, percorre a configuração passo a passo e mostra exemplos funcionais em Python que você pode adaptar.

Selenium product interface.
O Selenium sozinho inicia um navegador normal. Cada sessão compartilha os mesmos cookies, impressão digital de canvas, renderizador WebGL e user agent, então as plataformas podem vincular suas contas. O AdsPower resolve isso criando ambientes de navegador isolados com impressões digitais únicas (Canvas, WebGL, User Agent, IP e mais) e atribuição de proxy por perfil.
A combinação oferece:
Esse é o padrão por trás de operações de e-commerce multi-contas, marketing em redes sociais em escala, trabalho de afiliados e web scraping onde cada requisição deve parecer um visitante distinto.

Selenium product interface.
O AdsPower executa um serviço local na sua máquina. O Selenium não inicia o Chrome por conta própria; em vez disso, ele pede ao AdsPower para iniciar um perfil e então se conecta ao navegador já em execução através de uma interface de depuração.
O fluxo é:
selenium dentro de ws).debuggerAddress.Dois detalhes importam aqui. Primeiro, o WebDriver retornado pela API deve corresponder à versão do núcleo do navegador daquele perfil, por isso você deve usar o caminho que o AdsPower fornece em vez de um driver baixado separadamente. Segundo, a API Local escuta em http://local.adspower.net:50325 (ou http://127.0.0.1:50325), então nada precisa ser exposto à internet.
Antes de escrever código, confirme que você tem:
user_id).pip.Instale as dependências:
pip install selenium requests
O endpoint de início é uma requisição GET:
GET http://local.adspower.net:50325/api/v1/browser/start?user_id=<PROFILE_ID>
Parâmetros opcionais úteis incluem headless=1 para execuções em segundo plano, open_tabs=1 para pular a restauração de abas anteriores, ip_tab=0 para suprimir a página de detecção de IP, e launch_args para passar flags do Chrome como --disable-notifications. Uma resposta bem-sucedida se parece com isto:
{
"code": 0,
"data": {
"ws": {
"selenium": "127.0.0.1:xxxx",
"puppeteer": "ws://127.0.0.1:xxxx/devtools/browser/xxxxxx"
},
"debug_port": "xxxx",
"webdriver": "C:\\xxxx\\chromedriver.exe"
},
"msg": "success"
}
Se code não for 0, o perfil não foi iniciado. O campo msg geralmente indica se o ID do perfil está errado ou se a API Local não está em execução.

Selenium product interface.
Com Selenium 4.18 e mais recente, passe o caminho do WebDriver retornado para um objeto Service e defina debuggerAddress com o valor selenium:
import time
import requests
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.chrome.service import Service
import sys
ads_id = "your_profile_id"
api_key = "your_api_key_here"
open_url = f"http://local.adspower.net:50325/api/v1/browser/start?user_id={ads_id}"
close_url = f"http://local.adspower.net:50325/api/v1/browser/stop?user_id={ads_id}"
headers = {"Authorization": f"Bearer {api_key}"}
resp = requests.get(open_url, headers=headers).json()
if resp["code"] != 0:
print(resp["msg"])
sys.exit("Check the profile ID and Local API status")
chrome_driver = resp["data"]["webdriver"]
service = Service(executable_path=chrome_driver)
options = Options()
options.add_experimental_option("debuggerAddress", resp["data"]["ws"]["selenium"])
driver = webdriver.Chrome(service=service, options=options)
print(driver.title)
driver.get("https://www.browserscan.net/")
time.sleep(5)
driver.quit()
requests.get(close_url, headers=headers)
Em versões mais antigas do Selenium 3.x a mesma ideia se aplica, mas você passa o caminho do driver posicionalmente em vez de através de Service. Se você ainda está no 3.x, atualizar é a solução mais simples.
Abrir uma página de teste de impressão digital primeiro é um bom hábito. Isso confirma que o perfil está apresentando a impressão digital e o IP que você configurou antes de executar qualquer tarefa real.
Codificar isso em cada script fica confuso. Envolva em um gerenciador de contexto para que os perfis abram e fechem corretamente, mesmo quando uma tarefa falha:
from contextlib import contextmanager
BASE = "http://local.adspower.net:50325"
@contextmanager
def adspower_profile(profile_id, api_key=""):
headers = {"Authorization": f"Bearer {api_key}"} if api_key else {}
start = requests.get(
f"{BASE}/api/v1/browser/start",
params={"user_id": profile_id, "open_tabs": 1, "ip_tab": 0},
headers=headers,
).json()
if start["code"] != 0:
raise RuntimeError(start["msg"])
data = start["data"]
options = Options()
options.add_experimental_option("debuggerAddress", data["ws"]["selenium"])
driver = webdriver.Chrome(
service=Service(executable_path=data["webdriver"]), options=options
)
try:
yield driver
finally:
driver.quit()
requests.get(
f"{BASE}/api/v1/browser/stop",
params={"user_id": profile_id},
headers=headers,
)
Agora qualquer tarefa se torna três linhas:
with adspower_profile("profile_id_here", api_key) as driver:
driver.get("https://example.com/dashboard")
print(driver.title)
Uma tarefa comum é verificar se um lote de contas ainda faz login corretamente. Percorra os IDs de perfil, conecte o Selenium a cada um e registre o resultado:
profiles = ["id_001", "id_002", "id_003"]
results = {}
for pid in profiles:
try:
with adspower_profile(pid, api_key) as driver:
driver.get("https://example.com/login")
driver.find_element("id", "email").send_keys("user@example.com")
driver.find_element("id", "password").send_keys("secret")
driver.find_element("css selector", "button[type=submit]").click()
results[pid] = "ok" if "dashboard" in driver.current_url else "check"
except Exception as exc:
results[pid] = f"error: {exc}"
print(results)
Como cada perfil mantém seus próprios cookies, um perfil que fez login ontem ainda está logado hoje, e você pode pular completamente a etapa de login.
Se seu trabalho é scraping em vez de gerenciamento de contas, o mesmo helper se aplica, mas combine-o com uma API de scraping ou configuração de proxy rotativo. Para um padrão relacionado, veja Como Usar o AdsPower com Scrapestack: Configuração e Fluxo de Trabalho.
Execuções sequenciais são lentas quando você tem muitos perfis. Como cada perfil é um navegador independente, você pode executar vários ao mesmo tempo com threads:
from concurrent.futures import ThreadPoolExecutor
def scrape(pid):
with adspower_profile(pid, api_key) as driver:
driver.get("https://example.com/data")
return pid, driver.title
with ThreadPoolExecutor(max_workers=4) as pool:
for pid, title in pool.map(scrape, profiles):
print(pid, title)
Mantenha o número de workers modesto. Cada perfil em execução consome memória real, e paralelismo pesado em uma máquina vai desacelerar tudo ou causar timeouts. Quatro a oito perfis simultâneos é uma faixa inicial razoável em uma estação de trabalho típica.
O perfil inicia mas o Selenium não consegue conectar. O valor de debuggerAddress deve ser o campo selenium, não a URL WebSocket do puppeteer. São interfaces diferentes.
Sessão não criada ou incompatibilidade de versão do driver. Use o caminho webdriver retornado pela API. Ele é compatível com o núcleo do navegador daquele perfil. Um driver baixado manualmente muitas vezes não é.
A API retorna um código diferente de zero. Verifique se o ID do perfil está exato, se o perfil não está já aberto e se a API Local está habilitada nas configurações do AdsPower.
O navegador abre mas a página mostra a localização errada. O proxy está vinculado ao perfil, não ao seu código Selenium. Corrija nas configurações de proxy do perfil e confirme com uma página de verificação de impressão digital ou IP.
Scripts travam ao encerrar. Sempre chame driver.quit() e depois o endpoint de parada. Deixar perfis abertos bloqueia a próxima execução para aquele mesmo perfil.
O modo headless se comporta de forma diferente. Alguns sites detectam navegadores headless. Se uma tarefa falha apenas no modo headless, teste com uma janela visível primeiro para isolar a causa.

Selenium product interface.
| Cenário | Selenium puro | AdsPower + Selenium |
|---|---|---|
| Testar seu próprio aplicativo web | Boa opção | Sobrecarga desnecessária |
| Uma conta, uma máquina | Boa opção | Opcional |
| Muitas contas em um dispositivo | Impressões digitais colidem | Perfis isolados por conta |
| Proxy por conta | Configuração manual | Vinculado ao perfil |
| Logins persistentes entre execuções | Frágil | Armazenado dentro do perfil |
| Acesso da equipe aos mesmos perfis | Não suportado | Espaço de trabalho compartilhado |
Se sua automação só toca uma conta, o Selenium puro é mais simples. No momento em que a associação de contas se torna um risco, a camada antidetecção ganha seu lugar. Se você está comparando opções antidetecção antes de decidir, esta comparação AdsPower vs Incogniton vs BitBrowser cobre tratamento de impressão digital, suporte à automação e preços.
Quando uma única estação de trabalho não é suficiente, o Selenium Grid distribui sessões entre várias máquinas. A mesma ideia funciona aqui: cada nó do Grid executa sua própria instância do AdsPower com seu próprio conjunto de perfis, e seu script direciona o trabalho para o nó certo. Mantenha o mapeamento perfil-para-nó explícito para que um perfil nunca seja aberto duas vezes ao mesmo tempo.
A documentação da API Local do AdsPower cobre a lista completa de parâmetros para o endpoint de início, incluindo modo headless, argumentos de inicialização e limpeza de cache. A página oficial de exemplos de código inclui versões em Python, JavaScript e Java para Chrome e Firefox, e a referência do endpoint de abrir navegador documenta cada parâmetro de consulta e campo de retorno.
O AdsPower funciona com Selenium 4?
Sim. Selenium 4.18 e mais recente funcionam com o objeto Service mostrado acima. Selenium 3.141 também funciona com uma configuração de driver ligeiramente diferente.
Preciso de uma chave de API? Algumas versões do AdsPower exigem um token Bearer nos cabeçalhos da requisição. Se sua API Local aceita requisições não autenticadas, você pode omitir o cabeçalho.
Posso executar perfis do AdsPower em modo headless com Selenium?
Sim, passe headless=1 para o endpoint de início. Teste com cuidado, porque alguns sites tratam navegadores headless de forma diferente.
Quantos perfis podem ser executados ao mesmo tempo? Depende da memória e CPU da sua máquina. Cada perfil é uma instância completa de navegador. Comece com quatro perfis simultâneos e aumente gradualmente.
O Selenium vê o proxy do perfil? Sim. O proxy é configurado no perfil, então todo o tráfego daquela sessão de navegador sai por ele sem qualquer configuração de proxy do lado do Selenium.
Posso usar Firefox em vez de Chrome? O AdsPower suporta perfis Firefox com Selenium, mas requer um patch recente do AdsPower e Firefox 123 ou mais recente. O Chrome é o caminho mais comum e melhor documentado.
E quanto ao Puppeteer ou Playwright?
O mesmo endpoint de início retorna uma URL WebSocket puppeteer à qual o Playwright e o Puppeteer podem se conectar via CDP. Se sua stack é baseada em JavaScript, essa rota funciona igualmente bem.
AdsPower e Selenium dividem o trabalho de forma limpa: o AdsPower cuida da identidade, impressões digitais e proxies, enquanto o Selenium cuida das ações que seu script executa. A integração se resume a um padrão: iniciar o perfil através da API Local, ler o caminho do WebDriver e o endereço de depuração retornados, e conectar o Selenium ao navegador em execução.
Uma vez que essa função helper existe, escalar é apenas um loop ou um pool de threads. Adicione isolamento em nível de perfil, mantenha seu número de workers sensato e sempre feche os perfis quando uma tarefa terminar. Se você também gerencia lojas ou contas sociais manualmente junto com sua automação, um guia como Como Usar o AdsPower com Shopify: Guia de Configuração Multi-Loja mostra como a mesma estrutura de perfil suporta as operações do dia a dia.