Estudo de Caso7 min de leitura

Escalando o registro de contas em 50 perfis: um fluxo em lote real

Uma equipe combinou dados únicos por perfil, resolução automática de CAPTCHA e verificações de recuperação para manter consistente uma execução de cadastro em 50 navegadores do início ao fim.

8 de mar. de 2026

O Cenário

Uma equipe precisava registrar contas em uma plataforma em 50 perfis de navegador antideteção. Cada conta exigia um e-mail único, nome, número de telefone e senha. O fluxo de registro incluía verificação de e-mail, um desafio reCAPTCHA v2 e uma etapa de integração pós-registro.

Fazer isso manualmente levaria 3-4 horas. Com Ornold MCP e um agente de IA, todo o lote foi concluído em menos de 25 minutos — incluindo resolução de CAPTCHA e recuperação de erros.

Preparação: Dados por Perfil

O primeiro passo foi preparar dados únicos para cada um dos 50 perfis. Cada campo que o formulário de registro exigia precisava de um valor distinto por sessão. Reutilizar dados entre perfis é a forma mais rápida de ser sinalizado.

A equipe preparou um conjunto de dados com:

Endereços de e-mail únicos (um por perfil, de diferentes provedores)
Nomes realistas que correspondem às configurações de localidade/idioma do perfil
Senhas fortes (únicas por perfil, não sequenciais)
Números de telefone para verificação por SMS (de um serviço de números virtuais)

A qualidade dos dados é mais importante que a velocidade de automação. Um e-mail duplicado ou um nome obviamente falso pode desencadear detecção de fraude e sinalizar todo o lote. Invista tempo na criação de conjuntos de dados realistas e diversos.

// Exemplo de estrutura de conjunto de dados de perfil
const profiles = [
  { email: "sarah.mitchell@proton.me", name: "Sarah Mitchell", phone: "+1-555-0142", password: "kR9#mPx2vL" },
  { email: "james.wong@tutanota.com", name: "James Wong", phone: "+1-555-0198", password: "nT4$hQw8bJ" },
  // ... 48 perfis únicos adicionais
];

Fase 1: Inicialização e Navegação

Com 50 sessões Linken Sphere prontas (cada uma com seu próprio proxy, impressão digital e fuso horário), o primeiro passo foi navegar simultaneamente para a página de registro.

// Iniciar todas as sessões e navegar para a página de registro
await browser_list(); // Verificar que 50 sessões estão disponíveis
await browser_parallel_navigate({ url: "https://target.example/signup" });

// Aguardar o carregamento do formulário em todas as sessões
await browser_parallel_wait_for({
  text: "Create your account",
  timeoutMs: 20000
});

48 de 50 sessões carregaram a página de registro em 8 segundos. Duas sessões foram mais lentas devido à latência do proxy — o comando `wait_for` aguardou até que elas alcançassem a marca de 14 segundos.

Fase 2: Preenchimento de Formulário

Cada sessão precisava de seus próprios dados únicos. O comando de preenchimento paralelo do Ornold aceita um array de valores que mapeia 1:1 para sessões ativas:

// Preencher e-mail — cada sessão obtém um valor único
await browser_parallel_fill({
  ref: "email",
  values: profiles.map(p => p.email)
});

// Preencher nome
await browser_parallel_fill({
  ref: "fullname",
  values: profiles.map(p => p.name)
});

// Preencher senha
await browser_parallel_fill({
  ref: "password",
  values: profiles.map(p => p.password)
});

O preenchimento do formulário em todas as 50 sessões levou cerca de 3 segundos. O modo de interação baseado em DOM (gratuito, sem créditos de visão) lidou com os campos de formulário estruturados sem problemas.

Fase 3: Resolução de CAPTCHA

A página de registro tinha um desafio reCAPTCHA v2. Ornold o detectou em todas as 50 sessões e enviou solicitações de resolução em paralelo:

// Resolver CAPTCHAs em todas as 50 sessões
const captchaResult = await browser_solve_captcha();
// { total: 50, detected: 50, solved: 47, failed: 3 }

47 de 50 CAPTCHAs foram resolvidos na primeira tentativa (15-35 segundos). Três sessões falharam — o serviço de resolução expirou. Em vez de tentar novamente todo o lote, a equipe tentou novamente apenas as sessões que falharam:

// Tentar novamente as sessões que falharam
const retryResult = await browser_solve_captcha();
// Apenas sessões de destino que ainda têm CAPTCHAs não resolvidos
// { total: 3, detected: 3, solved: 3, failed: 0 }

A resolução de CAPTCHA é a etapa mais lenta na maioria dos fluxos de registro. Resolva após preencher o formulário (não antes) para minimizar a chance de expiração do token.

Fase 4: Envio e Verificação

Com formulários preenchidos e CAPTCHAs resolvidos, o próximo passo foi clicar no botão de envio e verificar se o registro foi bem-sucedido:

// Enviar o formulário
await browser_parallel_click({ ref: "submit" });

// Aguardar a página de sucesso
await browser_parallel_wait_for({
  text: "Check your email",
  timeoutMs: 15000
});

// Verificar status
const status = await browser_status();

Resultados após o envio:

46 sessões chegaram à página de confirmação "Check your email"
2 sessões receberam um desafio de segurança secundário (solicitação de verificação por telefone)
1 sessão recebeu um erro "too many requests"
1 sessão expirou durante o envio

Fase 5: Recuperação de Erros

Em vez de reiniciar todo o lote, a equipe tratou cada tipo de falha separadamente:

Verificação por telefone (2 sessões)

Essas sessões precisavam de uma etapa adicional. O agente de IA detectou o campo de entrada de telefone, preencheu os números virtuais do conjunto de dados e enviou. Ambas as sessões foram concluídas após a verificação por SMS.

Erro de limite de taxa (1 sessão)

O erro "too many requests" estava relacionado ao proxy — o IP havia sido usado recentemente. A equipe alterou o proxy da sessão e tentou novamente. O registro foi bem-sucedido na segunda tentativa.

Tempo limite excedido (1 sessão)

Um simples recarregamento de página e reenvio corrigiram isso. Os dados do formulário ainda estavam preenchidos (o navegador os preservou), então apenas a ação de envio precisava ser repetida.

Resultado final: 50 de 50 contas registradas com sucesso. Tempo total da primeira navegação até a última confirmação: 23 minutos.

O Que Tornou Isso Possível

Vários fatores transformaram isso de um script frágil em uma operação de lote confiável:

Dados por perfil — Cada sessão tinha dados únicos e realistas. Sem duplicatas, sem padrões.
Execução paralela — Todas as 50 sessões passaram por cada fase juntas, não uma de cada vez.
Recuperação seletiva — As falhas foram tratadas por sessão, não reiniciando o lote. O agente de IA identificou o que deu errado e aplicou a correção apropriada.
Verificações de status entre fases — Chamadas `browser_status()` e `wait_for` após cada etapa detectaram divergências cedo.
Lógica de repetição de CAPTCHA — As resoluções que falharam foram repetidas individualmente em vez de resolver todo o lote novamente.

Divisão de Tempo

Inicialização de sessão + navegação: ~15 segundos
Preenchimento de formulário (50 sessões): ~3 segundos
Resolução de CAPTCHA (primeira passagem): ~35 segundos
Repetição de CAPTCHA (3 sessões): ~25 segundos
Envio de formulário + verificação: ~10 segundos
Recuperação de erros (4 sessões): ~8 minutos
Total: ~23 minutos para 50 contas

Sem a fase de recuperação de erros, o caminho feliz para 46 sessões teria sido concluído em cerca de 2 minutos. A maior parte do tempo total foi gasta em resolução de CAPTCHA e tratamento de casos extremos — o que é esperado nesta escala.

Lições para Escalar Ainda Mais

A qualidade dos dados é o gargalo, não a velocidade de automação. Gaste mais tempo em conjuntos de dados realistas do que em otimizar o tempo de clique.
A qualidade do proxy afeta diretamente a taxa de sucesso. Proxies compartilhados baratos levam a limites de taxa e bloqueios. Proxies residenciais ou móveis funcionam significativamente melhor.
Não execute mais sessões do que sua máquina pode lidar. 50 instâncias do Chromium precisam de 16-24 GB de RAM. Monitore o uso de recursos e dimensione o hardware antes de dimensionar a contagem de sessões.
Construa recuperação no fluxo de trabalho desde o início. Com 50+ perfis, algumas falhas são garantidas. A questão é se você as trata automaticamente ou manualmente.
Teste primeiro com 5 perfis. Valide todo o fluxo de ponta a ponta antes de dimensionar para 50. A depuração em escala é exponencialmente mais difícil.
Distribua lotes grandes. Executar 100 perfis de uma vez a partir do mesmo intervalo de IP é uma bandeira vermelha. Divida-os em grupos de 20-30 com atrasos entre eles.