Como Usar o Navegador de Impressão Digital AdsPower com Python

Gerenciar várias contas online sem acionar bloqueios de plataforma é um desafio constante para vendedores de e-commerce, profissionais de marketing de afiliados e gerentes de mídias sociais. O navegador de impressão digital AdsPower resolve o problema de isolamento de impressões digitais, mas abrir e controlar manualmente dezenas de perfis de navegador é tedioso. É aí que o Python entra.

Ao combinar a API local do AdsPower com scripts Python, você pode automatizar todo o ciclo de vida dos perfis de navegador—criar, abrir, controlar e fechar programaticamente. Este guia mostra as etapas práticas, desde chamadas básicas de API até automação avançada usando Selenium e o protocolo MCP.

Por que Automatizar o AdsPower com Python?

Interface do produto e visão geral dos recursos do Como Usar o Navegador de Impressão Digital AdsPower com Python.

O AdsPower fornece ambientes de navegador isolados com impressões digitais digitais únicas, mas sua interface gráfica é projetada para operação manual. O Python adiciona uma camada de automação que permite:

• Criar e configurar perfis de navegador em massa – Configure centenas de perfis com diferentes proxies, impressões digitais e cookies automaticamente.
• Controlar ações do navegador programaticamente – Navegue para URLs, preencha formulários, clique em botões e extraia dados sem intervenção humana.
• Integrar com fluxos de trabalho existentes – Conecte o AdsPower aos seus pipelines de dados baseados em Python, sistemas de monitoramento ou agentes de IA.
• Escalar o gerenciamento de contas – Execute operações simultâneas em vários perfis de navegador a partir de um único script.

Entendendo a API Local do AdsPower

Interface do produto e visão geral dos recursos do Como Usar o Navegador de Impressão Digital AdsPower com Python.

O AdsPower expõe uma API HTTP local que roda em sua máquina. Por padrão, ela escuta em http://127.0.0.1:50325 (ou 50360 dependendo da sua versão). Esta API permite gerenciar perfis de navegador e controlar instâncias do navegador.

Principais Endpoints da API

Todas as chamadas de API são feitas para http://127.0.0.1:<porta>. A porta depende das configurações do seu AdsPower (o padrão é 50325 para versões mais recentes).

Pré-requisitos

Interface do produto e visão geral dos recursos do Como Usar o Navegador de Impressão Digital AdsPower com Python.

Antes de escrever qualquer código, certifique-se de ter:

• AdsPower instalado – Baixe de adspower.net e crie pelo menos um perfil de navegador.
• Python 3.8+ instalado em seu sistema.
• Pacotes Python necessários – Instale requests e opcionalmente selenium ou playwright.

pip install requests selenium

• API Local do AdsPower habilitada – Vá em Configurações do AdsPower > Configurações de API e anote o número da porta. Mantenha a porta padrão ou altere conforme necessário.

Passo 1: Listando Perfis de Navegador com Python

Interface do produto e visão geral dos recursos do Como Usar o Navegador de Impressão Digital AdsPower com Python.

O primeiro passo é verificar se seu script Python consegue se comunicar com o AdsPower. Comece listando todos os perfis de navegador existentes.

import requests

# URL base da API local do AdsPower
base_url = "http://127.0.0.1:50325"

# Obter lista de todos os perfis de navegador
response = requests.get(f"{base_url}/api/v1/user/list", params={"page": 1, "page_size": 100})
profiles = response.json()

if profiles["code"] == 0:
    for profile in profiles["data"]["list"]:
        print(f"ID: {profile['user_id']}, Nome: {profile['name']}, Proxy: {profile.get('proxy', 'Nenhum')}")
else:
    print("Erro:", profiles["msg"])

Este script retorna o ID do usuário, nome e configuração de proxy para cada perfil. O user_id é essencial para operações subsequentes.

Passo 2: Criando um Novo Perfil de Navegador com um Proxy

Criar um perfil programaticamente permite atribuir proxies e configurações de impressão digital únicos. Abaixo está um exemplo que cria um perfil com um proxy SOCKS5 especificado.

import requests
import json

base_url = "http://127.0.0.1:50325"

# Configuração do proxy
proxy_config = {
    "proxy_type": "socks5",
    "proxy_host": "192.168.1.100",
    "proxy_port": "1080",
    "proxy_user": "username",
    "proxy_password": "password"
}

# Dados do perfil
profile_data = {
    "name": "Meu Perfil Automatizado",
    "group_id": "",  # opcional: atribuir a um grupo
    "proxy_config": proxy_config,
    "fingerprint_config": {
        "language": ["pt-BR"],
        "timezone": "America/Sao_Paulo",
        "resolution": "1920x1080"
    }
}

response = requests.post(f"{base_url}/api/v1/user/create", json=profile_data)
result = response.json()

if result["code"] == 0:
    print(f"Perfil criado com sucesso. ID: {result['data']['id']}")
else:
    print(f"Falha ao criar perfil: {result['msg']}")

Você pode personalizar parâmetros de impressão digital como WebGL, Canvas, Áudio e WebRTC adicionando-os a fingerprint_config.

Passo 3: Iniciando um Perfil de Navegador e Obtendo a Porta de Depuração

Para controlar uma instância do navegador, primeiro você precisa iniciá-la e obter sua porta de depuração remota. A API do AdsPower retorna uma debug_port que você pode usar com Selenium ou Playwright.

import requests

base_url = "http://127.0.0.1:50325"
user_id = "seu_id_de_perfil_aqui"  # substitua pelo ID real

# Iniciar o navegador
response = requests.get(f"{base_url}/api/v1/browser/start", params={"user_id": user_id})
result = response.json()

if result["code"] == 0:
    debug_port = result["data"]["debug_port"]
    print(f"Navegador iniciado. Porta de depuração: {debug_port}")
    # Agora você pode conectar o Selenium a esta porta
else:
    print(f"Falha ao iniciar navegador: {result['msg']}")

A debug_port é a chave para conectar ferramentas de automação externas.

Passo 4: Controlando o Navegador com Selenium

Depois de obter a porta de depuração, você pode anexar o Selenium à instância do navegador já em execução. Isso preserva a impressão digital única enquanto permite automação completa.

from selenium import webdriver
from selenium.webdriver.chrome.options import Options

# Use a porta de depuração do passo anterior
debug_port = "12345"  # substitua pela porta real

chrome_options = Options()
chrome_options.add_experimental_option("debuggerAddress", f"127.0.0.1:{debug_port}")

driver = webdriver.Chrome(options=chrome_options)

# Agora você pode controlar o navegador
driver.get("https://example.com")
print(driver.title)

# Realize ações como login, preenchimento de formulários, etc.
# ...

driver.quit()

Esta abordagem é ideal para tarefas que exigem interação humana, como fazer login em contas de mídia social ou enviar formulários em plataformas de e-commerce.

Passo 5: Automatizando um Fluxo de Trabalho Completo

Vamos combinar tudo em um exemplo prático: criar um perfil, iniciá-lo, fazer login em um site e tirar uma captura de tela.

import requests
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
import time

base_url = "http://127.0.0.1:50325"

# Passo 1: Criar perfil
profile_data = {
    "name": "Teste de Fluxo de Trabalho",
    "proxy_config": {
        "proxy_type": "http",
        "proxy_host": "proxy.example.com",
        "proxy_port": "3128"
    }
}
create_resp = requests.post(f"{base_url}/api/v1/user/create", json=profile_data)
user_id = create_resp.json()["data"]["id"]
print(f"Perfil criado: {user_id}")

# Passo 2: Iniciar navegador
start_resp = requests.get(f"{base_url}/api/v1/browser/start", params={"user_id": user_id})
debug_port = start_resp.json()["data"]["debug_port"]
print(f"Navegador iniciado na porta {debug_port}")

# Passo 3: Conectar Selenium
chrome_options = Options()
chrome_options.add_experimental_option("debuggerAddress", f"127.0.0.1:{debug_port}")
driver = webdriver.Chrome(options=chrome_options)

# Passo 4: Realizar ações
driver.get("https://httpbin.org/ip")
time.sleep(2)
print("Página carregada:", driver.find_element("tag name", "body").text)

# Passo 5: Tirar captura de tela
driver.save_screenshot("screenshot_do_perfil.png")
print("Captura de tela salva")

# Passo 6: Limpeza
driver.quit()
requests.get(f"{base_url}/api/v1/browser/stop", params={"user_id": user_id})
print("Navegador parado")

Este script demonstra um ciclo completo: criar, iniciar, automatizar, capturar tela e parar. Você pode estendê-lo para percorrer vários perfis para operações em massa.

Avançado: Usando o Protocolo MCP para Automação de Páginas

O AdsPower também suporta o Model Context Protocol (MCP), que fornece uma maneira mais estruturada de controlar navegadores. Em vez de gerenciar manualmente portas de depuração, o MCP expõe ferramentas como navigate, click-element e fill-input.

Configurando o MCP com Python

1. Instale o SDK Python do MCP:

pip install mcp

1. Inicie o Servidor MCP do AdsPower (requer Node.js):

npx -y local-api-mcp-typescript

1. Conecte-se a partir do Python:

from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

async def main():
    server_params = StdioServerParameters(
        command="npx",
        args=["-y", "local-api-mcp-typescript"],
        env={"PORT": "50325", "API_KEY": "sua_chave_api"}
    )
    
    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()
            
            # Abrir um perfil de navegador
            result = await session.call_tool("open-browser", {"user_id": "id_do_perfil"})
            print(result)
            
            # Navegar para uma URL
            await session.call_tool("navigate", {"url": "https://example.com"})
            
            # Clicar em um elemento
            await session.call_tool("click-element", {"selector": "#botao-login"})

import asyncio
asyncio.run(main())

O MCP é particularmente útil quando você precisa integrar a automação do AdsPower em sistemas maiores orientados por IA ou quando deseja uma abstração mais limpa sobre comandos CDP brutos.

Problemas Comuns e Soluções

Conexão com a API Recusada

• Certifique-se de que o AdsPower está em execução e a API Local está habilitada.
• Verifique se a porta no script corresponde às Configurações de API do AdsPower.
• Se estiver usando um firewall, permita conexões com a porta da API local.

Navegador Falha ao Iniciar

• Verifique se o ID do perfil existe.
• Confirme que a configuração do proxy é válida.
• Consulte os logs do AdsPower para mensagens de erro detalhadas.

Selenium Não Consegue Conectar à Porta de Depuração

• Certifique-se de iniciar o navegador via API antes de conectar.
• Use exatamente a debug_port retornada pelo endpoint de início.
• Se estiver usando vários perfis, garanta que cada um tenha uma porta única.

Servidor MCP Não Encontrado

• Instale o Node.js e certifique-se de que npx está no seu PATH.
• Execute npx -y local-api-mcp-typescript manualmente primeiro para verificar se funciona.
• Verifique se a chave da API está correta.

Leitura relacionada

• Top 10 Aplicativos de Mensagens Baseados em Nuvem 2026 - Nosso ranking de 2026 dos 10 melhores aplicativos de mensagens baseados em nuvem. Critérios transparentes, análises baseadas em evidências e orientação para decisão para equipes e indivíduos.
• Como Usar o AdsPower com Proxy-Seller: Guia de Configuração Passo a Passo - Aprenda a configurar proxies Proxy-Seller no navegador de impressão digital AdsPower. Guia passo a passo, dicas de solução de problemas e casos de uso reais.

Perguntas Frequentes

Posso executar vários perfis de navegador simultaneamente com Python? Sim. Inicie cada perfil via API, colete suas portas de depuração e conecte instâncias separadas do Selenium a cada porta. Use threading ou asyncio para gerenciá-los concorrentemente.

Preciso instalar um driver de navegador diferente para o AdsPower? Não. O AdsPower usa Chromium internamente, então o ChromeDriver padrão funciona. Apenas certifique-se de que a versão do ChromeDriver corresponda à versão do Chromium usada pelo AdsPower.

É possível modificar parâmetros de impressão digital após a criação do perfil? Sim. Use o endpoint /api/v1/user/update para alterar proxy, configurações de impressão digital ou observações. Algumas alterações de impressão digital podem exigir reinicialização do navegador.

Como isso se compara ao uso do RPA integrado do AdsPower? O RPA do AdsPower é ótimo para fluxos de trabalho simples e sem código. A automação com Python oferece mais flexibilidade, lógica personalizada e integração com sistemas externos. Para tarefas complexas ou intensivas em dados, o Python é a melhor escolha.

Conclusão

Combinar o navegador de impressão digital AdsPower com Python desbloqueia poderosas capacidades de automação para gerenciamento de múltiplas contas. Seja criando perfis em massa, automatizando sequências de login ou construindo um painel completo de gerenciamento de contas, a API local do AdsPower fornece todos os ganchos necessários.

Comece com as chamadas básicas de API para listar e criar perfis, depois passe para a integração com Selenium para automação no nível da página. Para casos de uso mais avançados, explore o protocolo MCP para construir fluxos de trabalho orientados por IA. Com essas ferramentas, você pode gerenciar centenas de contas de forma eficiente, mantendo cada uma isolada com uma impressão digital única.

Para mais comparações e alternativas, confira nosso AdsPower vs Undetectable: Comparação de Navegadores Anti-Detecção 2026 e AdsPower vs VMLogin vs Kameleo: Confronto de Navegadores Anti-Detecção 2026. Se precisar de proxies confiáveis para seus perfis, nosso SOAX Review 2026 cobre preços e benchmarks de desempenho.