Como Usar o AdsPower com Selenium: Configuração e Exemplos

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.

Por que combinar AdsPower com Selenium

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:

• Isolamento de impressão digital por execução de automação. Cada sessão do Selenium se conecta a um perfil diferente do AdsPower, então duas execuções nunca parecem o mesmo dispositivo.
• Controle de proxy. O tráfego sai pelo proxy vinculado àquele perfil, não pelo seu IP local.
• Escala sem reescrever scripts. O mesmo código Selenium funciona em centenas de perfis alterando apenas um ID.
• Estado que persiste. Cookies e logins ficam dentro do perfil, então você autentica uma vez e reutiliza a sessão.

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.

Como a conexão realmente funciona

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 é:

1. Seu script chama a API Local do AdsPower para iniciar um perfil.
2. O AdsPower inicia o navegador daquele perfil com sua impressão digital e proxy.
3. A API retorna um caminho do WebDriver e um endereço de depuração (o valor selenium dentro de ws).
4. O Selenium se conecta a esse endereço usando debuggerAddress.
5. Seu script controla a página normalmente.
6. Ao terminar, você encerra o driver e chama o endpoint de parada.

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.

Pré-requisitos

Antes de escrever código, confirme que você tem:

• AdsPower instalado e pelo menos um perfil criado. Anote seu ID de perfil (também chamado de user_id).
• A API Local habilitada nas configurações do AdsPower.
• Python 3.8 ou mais recente com pip.
• O pacote Selenium instalado.
• Uma chave de API se sua versão do AdsPower exigir cabeçalhos de autorização.

Instale as dependências:

pip install selenium requests

Passo 1: Iniciar um perfil com a API Local

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.

Passo 2: Conectar o Selenium ao navegador 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.

Passo 3: Criar um helper reutilizável

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)

Exemplo prático: verificar contas em vários perfis

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.

Exemplo prático: executar perfis em paralelo

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.

Problemas comuns e correções

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.

AdsPower versus Selenium puro: quando cada um se encaixa

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.

Escalando além de uma máquina

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.

Leitura relacionada

• Configurações de Privacidade do Instagram: Guia Completo 2026 - Domine as configurações de privacidade do Instagram em 2026: proteja sua conta, controle o compartilhamento de dados, pare o rastreamento de anúncios e proteja configurações multi-contas com navegadores antidetecção.
• AdsPower vs Linken Sphere vs Indigo: Comparação de Navegadores Antidetecção - Comparamos AdsPower, Linken Sphere e Indigo: impressões digitais, automação, equipes, preços e casos de uso. Descubra qual navegador antidetecção escolher em 2026.

Fontes e leitura adicional

• Proxy-Seller × AdsPower: Tutorial de Web Scraping - Neste tutorial, combinamos o AdsPower (um navegador antidetecção) com o Proxy-Seller (um IP limpo e dedicado por perfil), conectamos à API Local do AdsPower e...

FAQ

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.

Conclusão

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.