Pular para o conteúdo principal
Está tendo problemas para obter o token?
Entre em contato com o suporte

Alibaba Cloud Captcha

Ver preço completo

Exemplos de tarefas​

A seguir estão exemplos de tipos de tarefas do Alibaba CAPTCHA que atualmente são suportados pelo serviço CapMonster Cloud:

Slider
Puzzle
Image restoration
Click
Atenção!

O CapMonster Cloud, por padrão, funciona com proxies integrados — já incluídos no custo do serviço. É necessário especificar seus próprios proxies apenas nos casos em que o site não aceita o token ou quando o acesso aos serviços integrados está restrito.

Se o proxy utiliza autenticação por IP, é necessário adicionar o endereço 65.21.190.34 à lista de permissões (whitelist).

Parâmetros da requisição​

type<string>required

CustomTask

class<string>required

alibaba

websiteURL<string>required

URL completo da página com o CAPTCHA.

sceneId (dentro de metadata)<string>required

Identificador do cenário do captcha, transmitido no seguinte formato: "sceneId":"1ww7426c4"— o valor é fornecido apenas como exemplo.
Utilize o seu próprio valor — as instruções para obtê-lo estão disponíveis na seção correspondente

prefix (dentro de metadata)<string>required

Parâmetro de inicialização do CAPTCHA, enviado na URL da requisição usada para carregar o texto da tarefa na página.
Por exemplo, se a URL for: https://dlw3kug.captcha-open.example.aliyuncs.com/, então o valor do parâmetro prefix corresponde ao subdomínio — dlw3kug.

Para alguns sites é necessário enviar parâmetros adicionais:

Utilize esses parâmetros apenas quando eles estiverem presentes no site (veja mais detalhes na seção Trabalhando com sites que contêm parâmetros estendidos).

userId (dentro de metadata)<string>optional

Identificador único do usuário ou da sessão no lado do site.
Exemplo: HpadJlQnz2zSKcSmjXBaqQvjYUvP4jMJIk/ZwGNDNiM=

userUserId (dentro de metadata)<string>optional

Identificador adicional (secundário) do usuário.
Exemplo: /uSXKkVFuuwxXA21/MpXGxpLStWBEup1B3jjlMUWwNE=

verifyType (dentro de metadata)<string>optional

Versão ou tipo do mecanismo de verificação do captcha.
Exemplo: 1.0

region (dentro de metadata)<string>optional

Região do servidor ou data center onde o captcha é processado.
Exemplo: sgp

UserCertifyId (dentro de metadata)<string>optional

ID único de verificação associado à sessão atual do captcha.
Exemplo: 0a03e59417757735511105780e2a5e

apiGetLib (dentro de metadata)<string>optional

Link para a biblioteca JS do captcha utilizada pelo site. O valor é gerado no lado do cliente e pode mudar dinamicamente a cada renderização da página.
Exemplo: https://o.example.com/captcha-frontend/aliyunCaptcha/AliyunCaptcha.js?t=2041

punishUrl (dentro de metadata)<string>optional

URL completo da página de verificação recebido do site de destino.

O parâmetro é usado em sites nos quais o Alibaba retorna uma URL separada /punish para realizar a verificação. Envie a URL completa, incluindo os parâmetros da consulta.

Exemplo: https://example.com:443//api/example/testlogin/_____tmd_____/punish?x5secdata=xgf6888e6c4d5d8115ka6bba95967ab87aa13767f97ccadf409d1782833032a-388365139a1244837524abakc3dafclick33ba7696f04104647438bcba5be532d2833__bx__example.com:443/api/example/testlogin/&x5step=2&action=captchaclick&pureCaptcha=

As instruções para obter a URL estão disponíveis na seção Como encontrar todos os parâmetros necessários para criar uma tarefa → punishUrl.

cookieRequired (dentro de metadata)<boolean>optional

Retorna cookies junto com a solução do CAPTCHA.

Use o valor true somente para sites que utilizam Alibaba WAF ou Amazon WAF e exigem cookies após a conclusão bem-sucedida da verificação.

Por padrão, esse parâmetro não é utilizado.

userAgent<string>optional

User-Agent do navegador. Use o valor atual compatível com o CapMonster Cloud: userAgentPlaceholder

Você pode obter o valor mais recente em: https://capmonster.cloud/api/useragent/actual.

proxyType<string>optional

http - proxy padrão http/https;
https - tente essa opção se "http" não funcionar (necessário para alguns proxies personalizados);
socks4 - proxy socks4;
socks5 - proxy socks5.

proxyAddress<string>optional

Endereço IP do proxy IPv4/IPv6. Não é permitido:

  • uso de proxies transparentes (aqueles que revelam o IP do cliente);
  • uso de proxies locais.

proxyPort<integer>optional

Porta do proxy.

proxyLogin<string>optional

Login do proxy.

proxyPassword<string>optional

Senha do proxy.

Variante com punishUrl​

Em alguns sites protegidos pelo Alibaba, a verificação é acionada por uma URL separada /punish. Nesse caso, envie a URL recebida no parâmetro punishUrl (dentro de metadata).

O Alibaba Punish pode usar verificações como seleção de imagens correspondentes ou slider.

POST
https://api.capmonster.cloud/createTask

Exemplo de requisição

{
  "clientKey": "API_KEY",
  "task": {
    "type": "CustomTask",
    "class": "alibaba",
    "websiteURL": "https://www.example.com",
    "userAgent": "userAgentPlaceholder",
    "metadata": {
      "punishUrl": "https://example.com/_____tmd_____/punish?x5secdata=your-x5secdata&x5step=2"
    }
  }
}

Exemplo de resposta

{
  "errorId": 0,
  "taskId": 407533077
}

Variante com retorno de cookies (cookieRequired)​

Para alguns sites que utilizam Alibaba WAF ou Amazon WAF, é necessário obter cookies após a resolução bem-sucedida. Esses cookies são utilizados nas solicitações subsequentes.

Para isso, adicione o seguinte parâmetro ao objeto metadata:

{
  "cookieRequired": true
}
POST
https://api.capmonster.cloud/createTask

Exemplo de requisição

{
  "clientKey": "API_KEY",
  "task": {
    "type": "CustomTask",
    "class": "alibaba",
    "websiteURL": "https://example.com",
    "userAgent": "userAgentPlaceholder",
    "metadata": {
      "prefix": "your-prefix",
      "sceneId": "your-scene-id",
      "userId": "your-user-id",
      "userUserId": "your-user-user-id",
      "verifyType": "1.0",
      "region": "sgp",
      "UserCertifyId": "your-user-certify-id",
      "apiGetLib": "https://o.example.com/captcha-frontend/aliyunCaptcha/AliyunCaptcha.js?t=2041",
      "cookieRequired": true
    }
  }
}

Exemplo de resposta

{
  "errorId": 0,
  "taskId": 407533077
}

Método de obter resultado da tarefa​

Use o método getTaskResult para obter a solução do Alibaba CAPTCHA.

POST
https://api.capmonster.cloud/getTaskResult

Exemplo de requisição

{
  "clientKey": "API_KEY",
  "taskId": 407533077
}

Exemplo de resposta

{
  "errorId": 0,
  "errorCode": null,
  "errorDescription": null,
  "status": "ready",
  "solution": {
    "data": {
      "tokens": "{\"sceneId\":\"1ww7426c4\",\"certifyId\":\"kBjCxX2W2c\",\"deviceToken\":\"U0dfV0VCIzM3...wOGJkMjY=\",\"data\":\"JRMnX3B...EUQdCpLkqSj7THYNf3dn\"}"
    }
  }
}

Se "cookieRequired": true tiver sido especificado na requisição, a resposta também conterá cookies agrupados por domínio. Isso também se aplica às tarefas com punishUrl. Use os cookies do objeto solution.domains nas requisições subsequentes ao domínio correspondente, juntamente com o resultado da resolução do CAPTCHA.

Exemplo de resposta

{
  "errorId": 0,
  "errorCode": null,
  "errorDescription": null,
  "status": "ready",
  "solution": {
    "domains": {
      "example.com": {
        "cookies": {
          "arms_uid": "23906d34-14da-4ddb-b651-b4d72d5376e1",
          "sca": "ec12103d",
          "atpsida": "b8cd8cc0185b...1196_1",
          "cna": "vJsNIxNBKGMCAax0zMDiXVu1",
          "cbc": "T2gAde24vOm4...wkkwYA=",
          "x5sec": "7b2274223a...227d",
          "tfstk": "gPEnRZi0vyuB...ECvCA."
        }
      }
    }
  }
}

Como encontrar todos os parâmetros necessários para criar uma tarefa​

sceneId​

O sceneId pode ser obtido após resolver o CAPTCHA com sucesso uma vez:

  1. Resolva o CAPTCHA manualmente no site.
  2. Abra o DevTools → aba Network.
  3. Encontre a requisição enviada após a verificação bem-sucedida (por exemplo: verify, check, validate).
  4. No Payload ou na Response, localize o parâmetro sceneId (CaptchaSceneId ou sId).

Este parâmetro também pode ser encontrado usando a busca nas requisições de rede:

  1. Abra a página com o CAPTCHA e vá para DevTools → aba Network.
  2. Use a busca (Ctrl + F) com a palavra-chave sceneId ou CaptchaSceneId.

prefix​

O prefix pode ser obtido a partir da URL da requisição usada no site para carregar o texto da tarefa do CAPTCHA:

  1. Abra a página com o CAPTCHA.
  2. Encontre a requisição relacionada ao carregamento da tarefa (geralmente via DevTools → Network).


punishUrl​

punishUrl é a URL de verificação do Alibaba retornada quando a proteção é acionada no site de destino.

Normalmente, essa URL pode ser obtida a partir de uma requisição de rede cuja resposta contém o seguinte erro:

FAIL_SYS_USER_VALIDATE

Obtenção de punishUrl pelo DevTools​

  1. Abra a página de destino e execute a ação que aciona a verificação do Alibaba.
  2. Abra o DevTools → Network.
  3. Encontre a requisição enviada no momento em que a proteção é acionada. Para facilitar a busca, procure uma resposta que contenha o erro FAIL_SYS_USER_VALIDATE.
  4. Abra a requisição encontrada e acesse a aba Preview. Na resposta, localize o campo data — ele contém a URL de verificação que deve ser usada como punishUrl.


  1. A mesma URL também pode ser encontrada na aba Response.


  1. Copie a URL completa e envie-a no parâmetro punishUrl (dentro de metadata) ao criar a tarefa.

A URL obtida deve conter uma porta (por exemplo, 443), o caminho _____tmd_____/punish e os parâmetros x5secdata, x5step, action e pureCaptcha.

Formato da URL:

https://example.com:443//api/example/testlogin/_____tmd_____/punish?x5secdata=xgf6888e6c4d5d8115ka6bba95967ab87aa13767f97ccadf409d1782833032a-388365139a1244837524abakc3dafclick33ba7696f04104647438bcba5be532d2833__bx__example.com:443/api/example/testlogin/&x5step=2&action=captchaclick&pureCaptcha=

Obtenção automática de punishUrl​

punishUrl também pode ser obtido programaticamente de uma das seguintes formas:

  • por requisições HTTP — quando são conhecidos a URL da API, o método, os headers e outros parâmetros da requisição;
  • por Playwright — quando é necessário capturar a requisição diretamente no navegador.

Em alguns casos, primeiro é retornada uma URL intermediária com x5secdata e x5step. Após o processamento, o punishUrl final também contém os parâmetros action e pureCaptcha.

Para requisições HTTP, use os parâmetros da requisição real do site de destino. No cenário com navegador, informe a página necessária e execute a ação que aciona o Alibaba Punish.

Importante

Os exemplos demonstram apenas o princípio geral de obtenção de punishUrl. Substitua a URL, os headers e outros valores pelos dados atuais do site de destino.

Mostrar código (por requisições HTTP)
const USER_AGENT =
  "userAgentPlaceholder";

const TIMEOUT = 30000;

/* ================= CONFIGURAÇÕES DA REQUISIÇÃO ================= */
// Todos os valores abaixo são fornecidos apenas como exemplo
// Informe os parâmetros da requisição real do site de destino
// Adicione headers extras, se necessário, como origin, referer e accept-language

const REQUEST_CONFIG = {
  pageUrl: "https://example.com/login",

  url: "https://api.example.com/login?fromSite=example&appName=example-app",

  method: "POST",

  // Query parameters da requisição, por exemplo: login, email,
  // número de telefone ou outros valores
  params: {
    value: "example"
  },

  headers: {
    accept: "application/json, text/plain, */*",
    "content-type": "application/json",
    "user-agent": USER_AGENT,
    origin: "https://example.com",
    referer: "https://example.com/login",
  },
};

/* ================= LÓGICA GERAL ================= */

function isPunishUrl(url) {
  return typeof url === "string" && url.includes("_____tmd_____/punish");
}

function hasParam(url, name) {
  try {
    return new URL(url).searchParams.has(name);
  } catch {
    return false;
  }
}

function isFinalPunishUrl(url) {
  return (
    isPunishUrl(url) &&
    ["x5secdata", "x5step", "action", "pureCaptcha"].every((name) =>
      hasParam(url, name),
    )
  );
}

function cookiesToHeader(cookies = {}) {
  return Object.entries(cookies)
    .map(([name, value]) => `${name}=${value}`)
    .join("; ");
}

function extractFromHtml(html, baseUrl) {
  const match = html.match(
    /(?:["']url["']\s*:\s*["']([^"']+)["'])|(https?:\/\/[^\s"'<>]+\/_____tmd_____\/punish\?[^\s"'<>]+)/i,
  );

  if (!match) {
    return null;
  }

  const value = (match[1] || match[2])
    .replace(/\\\//g, "/")
    .replace(/&amp;/g, "&")
    .replace(/&#x3D;|&#61;/gi, "=");

  try {
    const url = new URL(value, baseUrl).href;
    return isPunishUrl(url) ? url : null;
  } catch {
    return null;
  }
}

async function extractPunishUrl(response) {
  const text = await response.text();

  try {
    const url = JSON.parse(text)?.data?.url;

    if (isPunishUrl(url)) {
      return url;
    }
  } catch {}

  return extractFromHtml(text, response.url);
}

async function sendRequest(config) {
  const url = new URL(config.url);

  for (const [name, value] of Object.entries(config.params || {})) {
    if (value != null) {
      url.searchParams.set(name, value);
    }
  }

  const headers = {
    ...(config.headers || {}),
  };

  const cookie = cookiesToHeader(config.cookies);

  if (cookie) {
    headers.cookie = cookie;
  }

  const method = (config.method || "GET").toUpperCase();

  const options = {
    method,
    headers,
    signal: AbortSignal.timeout(TIMEOUT),
  };

  if (method !== "GET" && method !== "HEAD") {
    if (config.json != null) {
      options.body = JSON.stringify(config.json);
    } else if (config.data != null) {
      options.body = config.data;
    }
  }

  const response = await fetch(url, options);

  if (!response.ok) {
    throw new Error(`HTTP ${response.status} ${response.statusText}`);
  }

  return response;
}

async function resolvePunishUrl(response, config, maxSteps = 3) {
  const visited = new Set();

  for (let step = 0; step < maxSteps; step++) {
    const punishUrl = await extractPunishUrl(response);

    if (!punishUrl) {
      throw new Error("punishUrl não foi encontrado na resposta");
    }

    if (visited.has(punishUrl)) {
      throw new Error("Foi detectado um punishUrl repetido");
    }

    visited.add(punishUrl);

    if (isFinalPunishUrl(punishUrl)) {
      return punishUrl;
    }

    const headers = {
      accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
      "user-agent": USER_AGENT,
      referer: config.pageUrl,
    };

    const cookie = cookiesToHeader(config.cookies);

    if (cookie) {
      headers.cookie = cookie;
    }

    response = await fetch(punishUrl, {
      headers,
      signal: AbortSignal.timeout(TIMEOUT),
    });

    if (!response.ok) {
      throw new Error(`HTTP ${response.status} ${response.statusText}`);
    }
  }

  throw new Error("Não foi possível obter o punishUrl final");
}

async function main() {
  try {
    const response = await sendRequest(REQUEST_CONFIG);

    const punishUrl = await resolvePunishUrl(response, REQUEST_CONFIG);

    console.log("punishUrl final:");
    console.log(punishUrl);
  } catch (error) {
    console.error("Não foi possível obter punishUrl:");
    console.error(error.message);
  }
}

main();
Mostrar código (por Playwright)
const { chromium } = require("playwright");

// Página na qual o Alibaba Punish é utilizado
const PAGE_URL = "https://example.com/";

const TIMEOUT = 180000;

function isPunishUrl(url) {
  return (
    typeof url === "string" &&
    url.includes("_____tmd_____/punish")
  );
}

function hasParam(url, name) {
  try {
    return new URL(url).searchParams.has(name);
  } catch {
    return false;
  }
}

function isFinalPunishUrl(url) {
  return (
    isPunishUrl(url) &&
    hasParam(url, "x5secdata") &&
    hasParam(url, "x5step") &&
    hasParam(url, "action") &&
    hasParam(url, "pureCaptcha")
  );
}

function addHttpsPort(url) {
  if (
    typeof url !== "string" ||
    !url.startsWith("https://")
  ) {
    return url;
  }

  if (/^https:\/\/[^/]+:\d+(?:\/|$)/i.test(url)) {
    return url;
  }

  return url.replace(
    /^https:\/\/([^/]+)/i,
    "https://$1:443"
  );
}

function waitForPunishUrl(page) {
  return new Promise((resolve, reject) => {
    let finalPunishUrl = null;

    const timer = setTimeout(() => {
      cleanup();

      reject(
        new Error(
          "punishUrl final não foi encontrado"
        )
      );
    }, TIMEOUT);

    function cleanup() {
      clearTimeout(timer);

      page.off("request", onRequest);
      page.off("response", onResponse);
    }

    function processUrl(url) {
      if (
        finalPunishUrl ||
        !isFinalPunishUrl(url)
      ) {
        return;
      }

      finalPunishUrl =
        addHttpsPort(url);

      cleanup();
      resolve(finalPunishUrl);
    }

    function onRequest(request) {
      processUrl(
        request.url()
      );
    }

    function onResponse(response) {
      processUrl(
        response.url()
      );
    }

    page.on("request", onRequest);
    page.on("response", onResponse);
  });
}

async function main() {
  const browser = await chromium.launch({
    headless: false,
  });

  const context =
    await browser.newContext();

  const page =
    await context.newPage();

  const punishUrlPromise =
    waitForPunishUrl(page);

  await page.goto(
    PAGE_URL,
    {
      waitUntil: "domcontentloaded",
    }
  );

  console.log(
    "Execute na página a ação que aciona a verificação do Alibaba"
  );

  try {
    const punishUrl =
      await punishUrlPromise;

    console.log(
      "punishUrl final:"
    );

    console.log(punishUrl);
  } catch (error) {
    console.error(
      "Não foi possível obter punishUrl:"
    );

    console.error(
      error.message
    );
  }

  await browser.close();
}

main().catch(console.error);

Trabalhando com sites que contêm parâmetros estendidos​

Extração e preparação dos parâmetros de captcha​

Esta seção descreve o processo geral de extração dos parâmetros necessários, resolução do captcha e reenvio da requisição de autenticação no site alvo.

  1. Requisição inicial de autenticação:
POST https://example.com/api/v2/auths/signin

Os dados do usuário são enviados:

{
  "email": "[email protected]",
  "password": "hashed_password"
}

Exemplos de headers estão disponíveis na seção Exemplos de resolução automática de captcha.

  1. Detecção da resposta do servidor. O servidor pode retornar dois tipos de resposta:
  • 2.1 JSON padrão (sem captcha):
{
  "success": false,
  "data": {
    "code": "Bad_Request",
    "details": "The email or password provided is incorrect..."
  }
}

Isso significa que o captcha não é necessário e a requisição foi processada normalmente.

  • 2.2 Resposta com captcha (o servidor retorna uma página HTML em vez de JSON):
<!doctype html>
<meta charset="UTF-8">
<meta name="aliyun_waf_aa" content="...">
<meta name="aliyun_waf_bb" content="...">
...
  1. Dentro da página existe um objeto com os seguintes dados:
var requestInfo = {
  data,
  region,
  sceneId,
  token,
  traceid,
  type,
  userId,
  userUserId
}

Do objeto, devem ser extraídos os seguintes parâmetros usados para a resolução do captcha:

  • userId
  • userUserId
  • verifyType (corresponde a type)
  • region
  • UserCertifyId (corresponde a traceid)

Importante: além disso, é necessário armazenar os valores de autenticação token e traceid. Eles são usados nas requisições subsequentes de autenticação como u_atoken e u_asig, respectivamente.


  1. Exemplo de geração do link da biblioteca JS do captcha:
this.currentDate = new Date()

this.AliyunGeneratedDynamicJS =
  `https://o.example.com/captcha-frontend/aliyunCaptcha/AliyunCaptcha.js?t=${
    this.currentDate.getFullYear() +
    (this.currentDate.getMonth() + 1) +
    this.currentDate.getDate() +
    this.currentDate.getHours()
  }`
  1. Construção de metadata e da requisição de resolução do captcha.

Esses dados são enviados ao nosso serviço de resolução de captcha:

Importante: todos os valores indicados são fornecidos exclusivamente a título de exemplo. Antes de utilizá-los, substitua-os pelos dados atuais do seu projeto.

{
  "metadata": {
    "sceneId": "1ww7426c4",
    "prefix": "dlw3kug",
    "userId": "HpadJlQnz2zSKcSmjXBaqQvjYUvP4jMJIk/ZwGNDNiM=",
    "userUserId": "/uSXKkVFuuwxXA21/MpXGxpLStWBEup1B3jjlMUWwNE=",
    "verifyType": "1.0",
    "region": "sgp",
    "UserCertifyId": "0a03e59417757735511105780e2a5e",
    "apiGetLib": "https://o.example.com/captcha-frontend/aliyunCaptcha/AliyunCaptcha.js?t=2041"
  }
}
  1. Obtenção da solução do captcha e reenvio da requisição de autenticação com os parâmetros u_atoken e u_asig previamente salvos:
POST https://example.com/api/v2/auths/signin?u_atoken=...&u_asig=...&u_aref=undefined

Em caso de sucesso na resolução do captcha, o servidor retorna o resultado da autenticação (ver ponto 2.1).

Exemplos de resolução automática de captcha​

Importante

Os exemplos são apenas demonstrativos e mostram a lógica geral de funcionamento do seu site que utiliza proteção Alibaba Cloud Captcha. Em projetos reais, o código pode precisar de adaptação para um site específico, seus endpoints e headers.

Dados sensíveis (API keys, configurações de proxy, etc.) devem ser armazenados em .env ou em variáveis de ambiente.

Mostrar código (Node.js)
import "dotenv/config";
import fs from "fs";

import { gotScraping } from "got-scraping";

function parse(text, start, end, isJson = true) {
  const startIndex = text.indexOf(start);
  if (startIndex === -1) return null;

  const contentStart = startIndex + start.length;
  const endIndex = text.indexOf(end, contentStart);
  if (endIndex === -1) return null;

  let extracted = text.substring(contentStart, endIndex).trim();

  extracted = extracted.replace(/\n/g, "").trim();

  let jsonStr = extracted
    .replace(/(['"])?([a-zA-Z0-9_]+)(['"])?:/g, '"$2":')
    .replace(/'/g, '"');

  try {
    return isJson ? JSON.parse(jsonStr) : jsonStr;
  } catch (err) {
    console.error("Não foi possível fazer o parse do JSON:", err.message);
    console.error("Tentativa de parse:", jsonStr);
    return null;
  }
}

function buildProxyLine(proxyUrl) {
  if (!proxyUrl) return undefined;

  const parts = proxyUrl.split(":");

  // Tratamento do formato protocol:ip:port (3 partes)
  if (parts.length === 3) {
    const [protocol, ip, port] = parts;
    return { proxyLine: `${protocol}://${ip}:${port}`, protocol, ip, port };
  }

  // Tratamento do formato protocol:username:password:ip:port (5 partes)
  if (parts.length === 5) {
    const [protocol, username, password, ip, port] = parts;
    return {
      proxyLine: `${protocol}://${username}:${password}@${ip}:${port}`,
      protocol,
      ip,
      port,
      username,
      password,
    };
  }

  // Formato inválido
  return undefined;
}

const proxyUrl =
  process.env.proxyUrl || "http:username:password:127.0.0.1:9029"; // Substitua pelos dados do seu proxy ou defina no arquivo .env
const proxyLine = buildProxyLine(proxyUrl);
const delay = (ms) => new Promise((res) => setTimeout(res, ms));

class Worker {
  constructor() {
    this.providerVendorSolverUrl = "https://api.capmonster.cloud";
    this.API_KEY = process.env.apiKey || "YOUR_API_KEY"; // Substitua pela sua API key do CapMonster Cloud

    this.currentDate = new Date();
    // Aqui é gerado o link dinâmico da biblioteca JS do captcha
    this.AliyunGeneratedDynamicJS = `https://o.example.com/captcha-frontend/aliyunCaptcha/AliyunCaptcha.js?t=${this.currentDate.getFullYear() + (this.currentDate.getMonth() + 1) + this.currentDate.getDate() + this.currentDate.getHours()}`;

    this.websiteUrl = "https://example.com/auth"; // Substitua pela URL da página com captcha
    this.userAgent =
      "userAgentPlaceholder";
  }

  async executor() {
    console.log(`Obtendo parâmetros do captcha....`);

    const RequireAuthorizationResponses =
      await this.getAuthorizationResponses();

    console.log("Páginas com captcha recebidas com sucesso");

    const requireParamsCaptchas = await this.requireParamsCaptchasData(
      RequireAuthorizationResponses,
    );

    console.log(`Parâmetros do captcha: `, requireParamsCaptchas);

    const AlibabaSolvedResult = await this.requireAlibabaSolverResponse(
      requireParamsCaptchas,
    );

    console.log(
      `Resultado da resolução do captcha: `,
      AlibabaSolvedResult?.solution?.data?.tokens,
    );
    const RequireAuthorizationResponsesAfterCaptchaBypass =
      await this.sendAuthrozationsRequest();
    console.log(RequireAuthorizationResponsesAfterCaptchaBypass);
  }

  async sendAuthrozationsRequest() {
    const response = await gotScraping.post(
      `https://example.com/api/v2/auths/signin?u_atoken=${this.AuthorizationParams.u_atoken}&u_asig=${this.AuthorizationParams.u_asig}&u_aref=undefined`,
      {
        body: JSON.stringify({
          email: "[email protected]",
          password:
            "e2577eeb61dc2197dfe94816d731f2941ccd0b66de8dc97aacb377bfe8476970",
        }),
        headers: {
          Accept: "application/json, text/plain, */*",
          "Accept-Encoding": "gzip, deflate, br, zstd",
          "Accept-Language": "en-US,en;q=0.9",
          "Content-Type": "application/json",
          Origin: "https://example.com",
          Pragma: "no-cache",
          Referer: "https://example.com/auth",
          Timezone: "Thu Apr 09 2026 23:29:23 GMT+0300",
          "User-Agent":
            "userAgentPlaceholder",
          Version: "0.2.36",
          "X-Request-Id": "2b4a7a52-d273-4049-a826-156aae856fe5",
          "bx-v": "2.5.36",
          "sec-ch-ua":
            '"Chromium";v="150", "Not-A.Brand";v="24", "Google Chrome";v="150"',
          "sec-ch-ua-mobile": "?0",
          "sec-ch-ua-platform": '"Windows"',
          source: "web",
        },
      },
    );

    return response.body;
  }

  async getAuthorizationResponses() {
    const response = await gotScraping.post(
      `https://example.com/api/v2/auths/signin`, // Substitua pela URL correta de autenticação que aciona o captcha
      {
        body: JSON.stringify({
          email: "[email protected]",
          password:
            "e2577eeb61dc2197dfe94816d731f2941ccd0b66de8dc97aacb377bfe8476970",
        }),
        headers: {
          Accept: "application/json, text/plain, */*",
          "Accept-Encoding": "gzip, deflate, br, zstd",
          "Accept-Language": "en-US,en;q=0.9",
          "Content-Type": "application/json",
          Origin: "https://example.com", // Substitua pelo Origin correto do site
          Pragma: "no-cache",
          Referer: "https://example.com/auth", // Substitua pelo Referer correto do site
          Timezone: "Thu Apr 09 2026 23:29:23 GMT+0300",
          "User-Agent":
            "userAgentPlaceholder",
          Version: "0.2.36",
          "X-Request-Id": "2b4a7a52-d273-4049-a826-156aae856fe5",
          "bx-v": "2.5.36",
          "sec-ch-ua":
            '"Chromium";v="150", "Not-A.Brand";v="24", "Google Chrome";v="150"',
          "sec-ch-ua-mobile": "?0",
          "sec-ch-ua-platform": '"Windows"',
          source: "web",
        },
      },
    );

    if (response.body.includes("requestInfo")) {
      console.log("Resposta com captcha recebida com sucesso:");
      fs.writeFileSync("./baseResponse.txt", response.body);
      console.log(response.body.substring(0, 150));
      return response.body;
    }
    console.log(response.body);
    return await this.getAuthorizationResponses();
  }

  async requireAlibabaSolverResponse(captchaMetadataParams) {
    let cmReqData = {
      type: "CustomTask",
      class: "alibaba",
      websiteURL: this.websiteUrl,
      websiteKey: "customTask",
      userAgent: this.userAgent,
    };
    if (captchaMetadataParams) {
      cmReqData.metadata = captchaMetadataParams;
    }
    const response = await gotScraping.post(
      `${this.providerVendorSolverUrl}/createTask`,
      {
        body: JSON.stringify({ clientKey: this.API_KEY, task: cmReqData }),
        headers: {
          "Content-Type": "application/json",
        },
      },
    );
    let JSON_responseData = JSON.parse(response.body);
    if (JSON_responseData.errorId) throw new Error("JSON.TaskId.error");
    let taskId = JSON_responseData.taskId;
    let responseData;

    while (true) {
      let cmTaskRes = { clientKey: this.API_KEY, taskId: taskId };
      let task_response = await gotScraping.post(
        `${this.providerVendorSolverUrl}/getTaskResult`,
        {
          body: JSON.stringify(cmTaskRes),
          headers: {
            "Content-Type": "application/json",
          },
        },
      );
      let JSON_responseDataTaskResponse = JSON.parse(task_response.body);
      if (JSON_responseDataTaskResponse.status !== "processing") {
        responseData = JSON_responseDataTaskResponse;
        break;
      }
      await delay(5000);
    }
    return responseData;
  }

  async requireParamsCaptchasData(responsesCaptchaPage) {
    const JsonData = parse(
      responsesCaptchaPage,
      ':none">var requestInfo = ',
      ";",
      true,
    );

    // Salve os parâmetros de autorização para uso posterior na nova requisição de login
    this.AuthorizationParams = {
      u_atoken: JsonData.token,
      u_asig: JsonData.traceid,
    };
    return {
      prefix: "57d98d02303c01e7d2f7814c75224396",
      sceneId: JsonData.sceneId,
      userId: JsonData.userId,
      userUserId: JsonData.userUserId,
      verifyType: "1.0",
      region: JsonData.region,
      UserCertifyId: JsonData.traceid,
      apiGetLib: this.AliyunGeneratedDynamicJS,
    };
  }
}

new Worker().executor();
O artigo foi útil?
Confira os preços do solucionador de CAPTCHA com IA