Como combinar proxies MobileProxy.Space e resolução de CAPTCHA para automações estáveis
A maioria dos projetos de automação não falha por causa de código ruim. Eles falham por duas coisas que não têm nada a ver com a lógica do parser: reputação de IP e CAPTCHA.
Você escreve um scraper limpo, testa localmente e tudo funciona. Depois escala para 20 threads e de repente recebe 403s, telas infinitas de "verify you are human" e resultados vazios. A reação clássica é comprar mais proxies. A segunda é comprar um solver de CAPTCHA. Mas a solução real é fazer os dois funcionarem como um único sistema.
Este tutorial mostra como conectar proxies móveis do MobileProxy.Space com uma API de resolução de CAPTCHA automatizada para que o workflow sobreviva a execuções longas — com exemplos de código, lógica de retry e um checklist de erros que silenciosamente destroem a taxa de sucesso.proxies móveis do MobileProxy.Space com uma API de resolução de CAPTCHA automatizada para que o workflow sobreviva a execuções longas — com exemplos de código, lógica de retry e um checklist de erros que silenciosamente destroem a taxa de sucesso.
Por que só proxies não bastam
Proxies móveis são a opção mais forte para automação, porque IPs móveis são compartilhados por centenas de usuários reais via carrier NAT. Bloquear um endereço de forma agressiva prejudica clientes reais, então sistemas anti-bot tratam faixas móveis com mais tolerância.
Mas tolerância não é imunidade. Mesmo com um IP móvel perfeito, você ainda vai encontrar CAPTCHA quando:
- enviar requisições mais rápido do que um humano conseguiria;
- a fingerprint do navegador parecer automatizada;
- o site-alvo mostrar CAPTCHA para todo mundo em rotas específicas (login, checkout, busca);
- os cookies de sessão estiverem ausentes ou inconsistentes.
Por que um solver de CAPTCHA sozinho também não basta
Agora inverta. Suponha que você use apenas um serviço de resolução a partir de um IP de datacenter. O que acontece?
- o reCAPTCHA v3 retorna um score baixo, e o site rejeita o token mesmo sendo "válido";
- você recebe uma nova CAPTCHA imediatamente após resolver a anterior;
- a validação do token falha porque o IP que solicitou a CAPTCHA e o IP que a enviou não coincidem.
Princípio-chave: proxies reduzem com que frequência a CAPTCHA aparece. Um solver trata os casos que aparecem mesmo assim. Você precisa dos dois, e eles devem compartilhar o mesmo contexto de sessão.
A arquitetura
Este é o loop que um workflow estável segue:
┌──────────────┐
│ Task queue │
└──────┬───────┘
│
▼
┌────────────────────┐ ┌──────────────────────┐
│ Worker (session) │────▶│ MobileProxy.Space │
│ cookies + UA │ │ mobile IP + rotation │
└──────┬─────────────┘ └──────────────────────┘
│
│ CAPTCHA detected?
▼
┌────────────────────────┐
│ CAPTCHA solving API │──▶ token
└──────┬─────────────────┘
│
▼
┌────────────────────┐
│ Submit + validate │──▶ success / rotate IP / retry
└────────────────────┘
Passo 1. Prepare o proxy móvel
No painel do MobileProxy.Space você recebe um proxy com:
- host e porta (portas separadas para HTTP/HTTPS e SOCKS5);
- login e senha para autorização;
- um link de rotação de IP — uma URL que você chama para forçar um novo IP móvel;
- intervalo opcional de auto-rotação (por exemplo, a cada 5–15 minutos);
- seleção de geo, para alinhar o país do proxy à audiência-alvo do site.
Duas configurações importam mais para automação:
1. Modo de rotação. Use rotação manual por link para workflows orientados por lógica (rotacione só quando for bloqueado). Use rotação por timer para crawling amplo e stateless.
2. Intervalo de rotação. Se você rotacionar a cada 60 segundos enquanto um fluxo de login está em andamento, vai quebrar a própria sessão. Mantenha o intervalo maior do que a tarefa individual mais longa.
Checagem rápida antes de escrever qualquer lógica:
curl -x http://LOGIN:PASSWORD@proxy.host:PORT https://api.ipify.org
# → returns the current mobile IP
curl "https://mobileproxy.space/api.html?command=reboot&proxy_key=YOUR_KEY"
# → forces IP rotation (use your actual rotation link from the dashboard)
curl -x http://LOGIN:PASSWORD@proxy.host:PORT https://api.ipify.org
# → should return a different IP
Se o IP não mudar, corrija isso antes de depurar qualquer outra coisa.
Passo 2. Vincule o cliente a uma identidade de sessão
Uma sessão = um proxy + um cookie jar + um User-Agent + um conjunto de headers. Nunca misture.
Python requests
import requests
PROXY = "http://LOGIN:PASSWORD@proxy.host:PORT"
session = requests.Session()
session.proxies = {"http": PROXY, "https": PROXY}
session.headers.update({
"User-Agent": ("Mozilla/5.0 (Linux; Android 13; SM-S918B) "
"AppleWebKit/537.36 (KHTML, like Gecko) "
"Chrome/121.0.0.0 Mobile Safari/537.36"),
"Accept-Language": "en-US,en;q=0.9",
})
Detalhe pequeno, mas importante: se você usa um proxy móvel, use um User-Agent móvel e um viewport móvel. Um UA de Chrome desktop em um IP de operadora é uma inconsistência que sistemas de fingerprinting notam.
Playwright
from playwright.sync_api import sync_playwright
with sync_playwright() as p:
browser = p.chromium.launch(
proxy={
"server": "http://proxy.host:PORT",
"username": "LOGIN",
"password": "PASSWORD",
}
)
context = browser.new_context(
user_agent=("Mozilla/5.0 (Linux; Android 13; SM-S918B) "
"AppleWebKit/537.36 (KHTML, like Gecko) "
"Chrome/121.0.0.0 Mobile Safari/537.36"),
viewport={"width": 412, "height": 915},
is_mobile=True,
has_touch=True,
locale="en-US",
)
page = context.new_page()
page.goto("https://example.com")
Passo 3. Adicione resolução automatizada de CAPTCHA
Quando uma CAPTCHA aparece, o worker precisa de um token, não de um humano. É aí que entra um solver baseado em API: você envia os parâmetros da CAPTCHA, recebe um token ou texto e o submete no mesmo fluxo de requisição.
Neste tutorial eu uso o CapMonster Cloud — um solver de CAPTCHA com IA que trata reCAPTCHA v2/v3, Cloudflare Turnstile, CAPTCHAs de imagem e outros tipos comuns por meio de uma API simples de duas chamadas. O ponto importante para nós é que ele oferece suporte a tarefas vinculadas a proxy (proxy-bound tasks), exatamente o que você precisa ao trabalhar com IPs móveis.
Entendendo os dois modos de tarefa
Regra prática: se o site se importa com scores ou sessões, passe as credenciais do MobileProxy.Space na tarefa.
Extraindo o sitekey
Antes de resolver qualquer coisa, pegue o sitekey da página:
import re
html = session.get("https://target-site.com/login").text
match = re.search(r'data-sitekey="([^"]+)"', html)
sitekey = match.group(1) if match else None
No Playwright:
sitekey = page.get_attribute("[data-sitekey]", "data-sitekey")
Criando a tarefa e fazendo polling
import time, requests
API = "https://api.capmonster.cloud"
CLIENT_KEY = "YOUR_CLIENT_KEY"
def solve_recaptcha_v2(website_url, sitekey, proxy=None):
if proxy:
task = {
"type": "RecaptchaV2Task",
"websiteURL": website_url,
"websiteKey": sitekey,
"proxyType": "http",
"proxyAddress": proxy["host"],
"proxyPort": proxy["port"],
"proxyLogin": proxy["login"],
"proxyPassword": proxy["password"],
}
else:
task = {
"type": "RecaptchaV2TaskProxyless",
"websiteURL": website_url,
"websiteKey": sitekey,
}
r = requests.post(f"{API}/createTask",
json={"clientKey": CLIENT_KEY, "task": task},
timeout=30).json()
if r.get("errorId"):
raise RuntimeError(r.get("errorCode"))
task_id = r["taskId"]
for _ in range(40): # ~2 minutes max
time.sleep(3)
res = requests.post(f"{API}/getTaskResult",
json={"clientKey": CLIENT_KEY, "taskId": task_id},
timeout=30).json()
if res.get("status") == "ready":
return res["solution"]["gRecaptchaResponse"]
if res.get("errorId"):
raise RuntimeError(res.get("errorCode"))
raise TimeoutError("CAPTCHA task timed out")
Em seguida, injete o token no formulário e envie-o pela mesma sessão e pelo mesmo proxy:
token = solve_recaptcha_v2("https://target-site.com/login", sitekey, PROXY_CFG)
resp = session.post("https://target-site.com/login", data={
"username": "user",
"password": "pass",
"g-recaptcha-response": token,
})
Para automação de navegador, defina o token no DOM e dispare o callback do site:
page.evaluate("""(token) => {
document.querySelector('[name="g-recaptcha-response"]').value = token;
}""", token)
page.click("button[type=submit]")
Se preferir não escrever a lógica de polling você mesmo, há SDKs oficiais e guias de integração na documentação do CapMonster para Python, Node.js, C# e extensões de navegador.
Passo 4. A lógica de cola: quando rotacionar, quando resolver
É daqui que a estabilidade realmente vem. Trate cada resposta como um sinal e reaja de acordo.
def handle(response, ctx):
if response.status_code == 200 and not has_captcha(response.text):
return "OK"
if has_captcha(response.text):
ctx["captcha_count"] += 1
# solve first, rotate only if solving keeps failing
if ctx["captcha_count"] <= 2:
return "SOLVE"
return "ROTATE_AND_RETRY"
if response.status_code in (403, 429):
return "ROTATE_AND_RETRY"
if response.status_code >= 500:
return "BACKOFF_RETRY"
return "FAIL"
Regras de rotação que funcionam na prática
- Nunca rotacione no meio do fluxo. Rotacionar entre "carregar CAPTCHA" e "enviar token" invalida o token.
- Rotacione após N bloqueios consecutivos, não após cada erro isolado.
- Reinicie a sessão na rotação. Novo IP → novo cookie jar → novo UA. Um cookie que volta em um IP móvel novinho parece estranho.
- Adicione jitter. Faça sleep de random.uniform(1.5, 4.0) entre requisições em vez de um atraso fixo.
- Limite a concorrência por IP. Um IP móvel rodando 50 threads paralelas já é uma fingerprint por si só. 3–8 requisições concorrentes por proxy é um intervalo inicial sensato.
import random, time
def rotate(ctx):
requests.get(ROTATION_LINK, timeout=60)
time.sleep(random.uniform(8, 15)) # let the carrier assign a new IP
ctx["session"] = new_session() # fresh cookies + headers
ctx["captcha_count"] = 0
Passo 5. Meça o que importa
Registre estas quatro métricas por execução — elas mostram exatamente qual camada está falhando:
Diagnóstico útil: se a taxa de CAPTCHA está alta mas a taxa de sucesso da resolução também está alta, seus proxies e o pacing precisam de ajuste. Se a taxa de CAPTCHA é baixa mas a resolução vai mal, a lógica de envio do token ou o binding do proxy está errado.
Checklist de armadilhas comuns
- ❌ User-Agent de desktop em um proxy móvel
- ❌ Enviar websiteURL como endpoint da API em vez da URL da página
- ❌ Resolver CAPTCHA em um IP e enviar o token em outro
- ❌ Reutilizar um token (eles são de uso único e de curta duração)
- ❌ Sem timeout no loop de polling → workers travados
- ❌ Rotacionar IP a cada erro, queimando IPs e sessões
- ❌ Ignorar Accept-Language / fuso horário vs. mismatch de geo do proxy
- ❌ Hardcodar sitekeys que o site rotaciona
Mini caso: estabilizando um job de monitoramento de preços
Uma equipe que raspava ~35.000 páginas de produtos por dia tinha 61% de taxa de sucesso. Setup deles: proxies de datacenter, delay fixo de 1 segundo, resolução de CAPTCHA proxyless.
O que mudou:
- Migrou para proxies móveis com rotação manual acionada por sinais de bloqueio em vez de timer.
- Alinhou UA móvel + viewport + is_mobile ao tipo de proxy.
- Mudou endpoints sensíveis a score para tarefas de resolução proxy-bound.
- Adicionou delays aleatórios de 1,5–4 s e limitou a concorrência a 6 por IP.
- Adicionou retry com backoff exponencial em 5xx.
Resultado após uma semana: taxa de sucesso 94%, taxa de CAPTCHA caiu de 23% para 6%, e o gasto com solver diminuiu — porque menos CAPTCHAs apareceram desde o início.
Esse é o ponto: proxies e resolução de CAPTCHA não são linhas de custo concorrentes. Proxies melhores reduzem a conta do solver, e um solver confiável evita que seus proxies sejam desperdiçados em retries sem saída.
Checklist final de deploy
- Proxy verificado via curl + link de rotação testado
- Intervalo de rotação maior do que a tarefa individual mais longa
- Uma sessão = um proxy + um cookie jar + uma fingerprint
- UA e viewport móveis para IPs móveis
- Sitekey extraído dinamicamente, sem hardcode
- Tarefas de resolução proxy-bound para fluxos sensíveis a score
- Timeout + limite de retry em cada chamada de resolução
- Logging estruturado das quatro métricas principais
- Degradação graciosa: recoloque a tarefa na fila em vez de descartá-la
Monte o loop uma vez, registre tudo e ajuste com dados em vez de palpites. É assim que um script frágil vira um workflow de automação que você pode deixar rodando a noite toda.
