Cách giải Captcha trong Maxun với tích hợp CapSolver

# Cài đặt SDK Maxun
npm install maxun-sdk

# Cài đặt các phụ thuộc bổ sung cho tích hợp CapSolver
npm install axios

# Sao chép kho lưu trữ Maxun
git clone https://github.com/getmaxun/maxun.git
cd maxun

# Chạy bằng Docker Compose
docker-compose up -d

CAPSOLVER_API_KEY=your_capsolver_api_key
MAXUN_API_KEY=your_maxun_api_key

# Đối với Maxun Cloud (app.maxun.dev)
MAXUN_BASE_URL=https://app.maxun.dev/api/sdk

# Đối với Maxun tự lưu trữ (mặc định)
# MAXUN_BASE_URL=http://localhost:8080/api/sdk

import axios, { AxiosInstance } from 'axios';

interface TaskResult {
  gRecaptchaResponse?: string;
  token?: string;
  cookies?: Array<{ name: string; value: string }>;
  userAgent?: string;
}

interface CapSolverConfig {
  apiKey: string;
  timeout?: number;
  maxAttempts?: number;
}

class CapSolverService {
  private client: AxiosInstance;
  private apiKey: string;
  private maxAttempts: number;

  constructor(config: CapSolverConfig) {
    this.apiKey = config.apiKey;
    this.maxAttempts = config.maxAttempts || 60;

    this.client = axios.create({
      baseURL: 'https://api.capsolver.com',
      timeout: config.timeout || 30000,
      headers: { 'Content-Type': 'application/json' },
    });
  }

  private async createTask(taskData: Record<string, unknown>): Promise<string> {
    const response = await this.client.post('/createTask', {
      clientKey: this.apiKey,
      task: taskData,
    });

    if (response.data.errorId !== 0) {
      throw new Error(`Lỗi CapSolver: ${response.data.errorDescription}`);
    }

    return response.data.taskId;
  }

  private async getTaskResult(taskId: string): Promise<TaskResult> {
    for (let attempt = 0; attempt < this.maxAttempts; attempt++) {
      await this.delay(2000);

      const response = await this.client.post('/getTaskResult', {
        clientKey: this.apiKey,
        taskId,
      });

      const { status, solution, errorDescription } = response.data;

      if (status === 'ready') {
        return solution as TaskResult;
      }

      if (status === 'failed') {
        throw new Error(`Nhiệm vụ thất bại: ${errorDescription}`);
      }
    }

    throw new Error('Hết thời gian chờ giải CAPTCHA');
  }

  private delay(ms: number): Promise<void> {
    return new Promise((resolve) => setTimeout(resolve, ms));
  }

  async solveReCaptchaV2(websiteUrl: string, websiteKey: string): Promise<string> {
    const taskId = await this.createTask({
      type: 'ReCaptchaV2TaskProxyLess',
      websiteURL: websiteUrl,
      websiteKey,
    });

    const solution = await this.getTaskResult(taskId);
    return solution.gRecaptchaResponse || '';
  }

  async solveReCaptchaV3(
    websiteUrl: string,
    websiteKey: string,
    pageAction: string = 'submit'
  ): Promise<string> {
    const taskId = await this.createTask({
      type: 'ReCaptchaV3TaskProxyLess',
      websiteURL: websiteUrl,
      websiteKey,
      pageAction,
    });

    const solution = await this.getTaskResult(taskId);
    return solution.gRecaptchaResponse || '';
  }

  async solveTurnstile(
    websiteUrl: string,
    websiteKey: string,
    action?: string,
    cdata?: string
  ): Promise<string> {
    const taskData: Record<string, unknown> = {
      type: 'AntiTurnstileTaskProxyLess',
      websiteURL: websiteUrl,
      websiteKey,
    };

    // Thêm thông tin tùy chọn
    if (action || cdata) {
      taskData.metadata = {};
      if (action) (taskData.metadata as Record<string, string>).action = action;
      if (cdata) (taskData.metadata as Record<string, string>).cdata = cdata;
    }

    const taskId = await this.createTask(taskData);
    const solution = await this.getTaskResult(taskId);
    return solution.token || '';
  }

  async checkBalance(): Promise<number> {
    const response = await this.client.post('/getBalance', {
      clientKey: this.apiKey,
    });

    return response.data.balance || 0;
  }
}

export { CapSolverService, CapSolverConfig, TaskResult };

import { Trích xuất } from 'maxun-sdk';
import { CapSolverService } from './capsolver-service';

const CAPSOLVER_API_KEY = process.env.CAPSOLVER_API_KEY!;
const MAXUN_API_KEY = process.env.MAXUN_API_KEY!;
const MAXUN_BASE_URL = process.env.MAXUN_BASE_URL || 'https://app.maxun.dev/api/sdk';

const capSolver = new CapSolverService({ apiKey: CAPSOLVER_API_KEY });
const extractor = new Trích xuất({
  apiKey: MAXUN_API_KEY,
  baseUrl: MAXUN_BASE_URL,
});

async function trích xuấtVớiReCaptchaV2() {
  const targetUrl = 'https://example.com/trang-bảo-mật';
  const reCAPTCHA_siteKey = '6LcxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxABC';

  console.log('Giải reCAPTCHA v2...');

  // Giải CAPTCHA trước tiên
  const token = await capSolver.solveReCaptchaV2(targetUrl, reCAPTCHA_siteKey);

  console.log('CAPTCHA đã được giải, tạo robot trích xuất...');

  // Tạo robot bằng cách chuỗi phương thức
  const robot = await extractor
    .tạo('Trình trích xuất sản phẩm')
    .điều hướng(targetUrl)
    .nhập('#g-recaptcha-response', token)
    .nhấn('nút[type="submit"]')
    .chờ(2000)
    .thu-thập-danh-sách({ selector: '.sản-phẩm' });

  // Chạy robot
  const kết_quả = await robot.chạy({ timeout: 30000 });

  console.log('Trích xuất hoàn tất:', kết_quả.dữ_liệu);
  return kết_quả.dữ_liệu;
}

trích xuấtVớiReCaptchaV2().catch(console.error);

import { Trích xuất } from 'maxun-sdk';
import { CapSolverService } from './capsolver-service';

const CAPSOLVER_API_KEY = process.env.CAPSOLVER_API_KEY!;
const MAXUN_API_KEY = process.env.MAXUN_API_KEY!;
const MAXUN_BASE_URL = process.env.MAXUN_BASE_URL || 'https://app.maxun.dev/api/sdk';

const capSolver = new CapSolverService({ apiKey: CAPSOLVER_API_KEY });
const extractor = new Trích xuất({
  apiKey: MAXUN_API_KEY,
  baseUrl: MAXUN_BASE_URL,
});

async function trích xuấtVớiReCaptchaV3() {
  const targetUrl = 'https://example.com/v3-bảo-mật';
  const reCAPTCHA_siteKey = '6LcxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxDEF';

  console.log('Giải reCAPTCHA v3 với điểm số cao...');

  // Giải với hành động trang tùy chỉnh
  const token = await capSolver.solveReCaptchaV3(
    targetUrl,
    reCAPTCHA_siteKey,
    'submit'  // hành động trang
  );

  console.log('Token đã được nhận với điểm số cao, tạo robot...');

  // Tạo robot trích xuất bằng cách chuỗi phương thức
  const robot = await extractor
    .tạo('Trình trích xuất bảo vệ v3')
    .điều hướng(targetUrl)
    .nhập('input[name="g-recaptcha-response"]', token)
    .nhấn('#nút-gửi')
    .chờ(2000)
    .thu-thập-text({ kết_quả: '.kết_quả' });

  const kết_quả = await robot.chạy({ timeout: 30000 });

  console.log('Dữ liệu trích xuất:', kết_quả.dữ_liệu);
  return kết_quả.dữ_liệu;
}

trích xuấtVớiReCaptchaV3().catch(console.error);

import { Trích xuất } from 'maxun-sdk';
import { CapSolverService } from './capsolver-service';

const CAPSOLVER_API_KEY = process.env.CAPSOLVER_API_KEY!;
const MAXUN_API_KEY = process.env.MAXUN_API_KEY!;
const MAXUN_BASE_URL = process.env.MAXUN_BASE_URL || 'https://app.maxun.dev/api/sdk';

const capSolver = new CapSolverService({ apiKey: CAPSOLVER_API_KEY });
const scraper = new Trích xuất({
  apiKey: MAXUN_API_KEY,
  baseUrl: MAXUN_BASE_URL,
});

async function trích xuấtVớiTurnstile() {
  const targetUrl = 'https://example.com/turnstile-bảo-mật';
  const turnstile_siteKey = '0x4xxxxxxxxxxxxxxxxxxxxxxxxxxxxGHI';

  console.log('Giải Cloudflare Turnstile...');

  // Giải với thông tin tùy chọn (action và cdata)
  const token = await capSolver.solveTurnstile(
    targetUrl,
    turnstile_siteKey,
    'đăng nhập',                              // hành động tùy chọn
    '0000-1111-2222-3333-thông-tin-cdata'  // thông tin cdata tùy chọn
  );

  console.log('Turnstile đã được giải, tạo robot trích xuất...');

  // Tạo robot trích xuất - đối với Turnstile, chúng ta thường cần
  // gửi token qua yêu cầu POST trước, sau đó trích xuất
  const robot = await scraper.tạo('trình-trích-xuất-turnstile', targetUrl, {
    định_dạng: ['markdown', 'html'],
  });

  const kết_quả = await robot.chạy({ timeout: 30000 });

  console.log('Trích xuất hoàn tất');
  console.log('Markdown:', kết_quả.dữ_liệu.markdown?.substring(0, 500));
  return kết_quả.dữ_liệu;
}

trích xuấtVớiTurnstile().catch(console.error);

import { Trích xuất } from 'maxun-sdk';
import { CapSolverService } from './capsolver-service';

const capSolver = new CapSolverService({ apiKey: process.env.CAPSOLVER_API_KEY! });
const extractor = new Trích xuất({
  apiKey: process.env.MAXUN_API_KEY!,
  baseUrl: process.env.MAXUN_BASE_URL || 'https://app.maxun.dev/api/sdk',
});

interface DữLiệuSảnPhẩm {
  tên: string;
  giá: string;
  đánh_giá: string;
}

async function trích xuấtSảnPhẩmVớiCaptcha(): Promise<DữLiệuSảnPhẩm[]> {
const targetUrl = 'https://example.com/products';
  const siteKey = '6LcxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxABC';

  // Giải CAPTCHA trước
  const captchaToken = await capSolver.solveReCaptchaV2(targetUrl, siteKey);

  console.log('CAPTCHA đã được giải, tạo robot trích xuất...');

  // Tạo robot trích xuất bằng cách kế thừa phương thức
  const robot = await extractor
    .create('Trình trích xuất sản phẩm')
    .navigate(targetUrl)
    .type('#g-recaptcha-response', captchaToken)
    .click('button[type="submit"]')
    .wait(3000)
    .captureList({
      selector: '.product-card',
      pagination: { type: 'clickNext', selector: '.next-page' },
      maxItems: 50,
    });

  // Chạy trích xuất
  const result = await robot.run({ timeout: 60000 });

  return result.data.listData as ProductData[];
}

extractProductsWithCaptcha()
  .then((products) => {
    products.forEach((product) => {
      console.log(`${product.name}: ${product.price}`);
    });
  })
  .catch(console.error);

import { Scrape } from 'maxun-sdk';
import { CapSolverService } from './capsolver-service';
import axios from 'axios';

const capSolver = new CapSolverService({ apiKey: process.env.CAPSOLVER_API_KEY! });
const scraper = new Scrape({
  apiKey: process.env.MAXUN_API_KEY!,
  baseUrl: process.env.MAXUN_BASE_URL || 'https://app.maxun.dev/api/sdk',
});

interface ScrapeResult {
  url: string;
  markdown?: string;
  html?: string;
  captchaSolved: boolean;
}

async function scrapeWithCaptchaHandling(): Promise<ScrapeResult[]> {
  const urls = [
    'https://example.com/page1',
    'https://example.com/page2',
    'https://example.com/page3',
  ];

  const results: ScrapeResult[] = [];

  for (const url of urls) {
    try {
      // Đối với các trang bị CAPTCHA, giải trước và thiết lập phiên
      const siteKey = '6LcxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxABC'; // Lấy động nếu cần

      console.log(`Giải CAPTCHA cho ${url}...`);
      const captchaToken = await capSolver.solveReCaptchaV2(url, siteKey);

      // Gửi CAPTCHA để nhận cookie phiên
      const verifyResponse = await axios.post(`${url}/verify`, {
        'g-recaptcha-response': captchaToken,
      });

      // Tạo robot ghi chú cho trang đã xác thực
      const robot = await scraper.create(`scraper-${Date.now()}`, url, {
        formats: ['markdown', 'html'],
      });

      const result = await robot.run({ timeout: 30000 });

      results.push({
        url,
        markdown: result.data.markdown,
        html: result.data.html,
        captchaSolved: true,
      });

      // Dọn dẹp - xóa robot sau khi sử dụng
      await robot.delete();

    } catch (error) {
      console.error(`Không thể ghi chú ${url}:`, error);
      results.push({ url, captchaSolved: false });
    }
  }

  return results;
}

scrapeWithCaptchaHandling().then(console.log).catch(console.error);

import { Crawl } from 'maxun-sdk';
import { CapSolverService } from './capsolver-service';
import axios from 'axios';

const capSolver = new CapSolverService({ apiKey: process.env.CAPSOLVER_API_KEY! });
const crawler = new Crawl({
  apiKey: process.env.MAXUN_API_KEY!,
  baseUrl: process.env.MAXUN_BASE_URL || 'https://app.maxun.dev/api/sdk',
});

interface PageResult {
  url: string;
  title: string;
  text: string;
  wordCount: number;
}

async function crawlWithCaptchaProtection(): Promise<PageResult[]> {
  const startUrl = 'https://example.com';
  const siteKey = '6LcxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxABC';

  // Giải CAPTCHA cho miền trước
  console.log('Giải CAPTCHA để truy cập miền...');
  const captchaToken = await capSolver.solveReCaptchaV2(startUrl, siteKey);

  // Gửi CAPTCHA để thiết lập phiên (tùy theo miền)
  await axios.post(`${startUrl}/verify`, {
    'g-recaptcha-response': captchaToken,
  });

  // Tạo robot ghi chú với cấu hình theo miền
  const robot = await crawler.create('site-crawler', startUrl, {
    mode: 'domain',           // Phạm vi ghi chú: 'domain', 'subdomain', hoặc 'path'
    limit: 50,                // Số trang tối đa để ghi chú
    maxDepth: 3,              // Sâu tối đa để theo dõi liên kết
    useSitemap: true,         // Phân tích sitemap.xml để lấy URL
    followLinks: true,        // Trích xuất và theo dõi liên kết trang
    includePaths: ['/blog/', '/docs/'],  // Mẫu regex để bao gồm
    excludePaths: ['/admin/', '/login/'], // Mẫu regex để loại trừ
    respectRobots: true,      // Tôn trọng robots.txt
  });

  // Chạy ghi chú
  const result = await robot.run({ timeout: 120000 });

  // Mỗi trang trong kết quả chứa: metadata, html, text, wordCount, links
  return result.data.crawlData.map((page: any) => ({
    url: page.metadata.url,
    title: page.metadata.title,
    text: page.text,
    wordCount: page.wordCount,
  }));
}

crawlWithCaptchaProtection()
  .then((pages) => {
    console.log(`Đã ghi chú ${pages.length} trang`);
    pages.forEach((page) => {
      console.log(`- ${page.title}: ${page.url} (${page.wordCount} từ)`);
    });
  })
  .catch(console.error);

import axios from 'axios';
import { Extract } from 'maxun-sdk';
import { CapSolverService } from './capsolver-service';

const capSolver = new CapSolverService({ apiKey: process.env.CAPSOLVER_API_KEY! });
const extractor = new Extract({
  apiKey: process.env.MAXUN_API_KEY!,
  baseUrl: process.env.MAXUN_BASE_URL || 'https://app.maxun.dev/api/sdk',
});

interface SessionCookies {
  name: string;
  value: string;
  domain: string;
}

async function preAuthenticateWithCaptcha(
  loginUrl: string,
  siteKey: string
): Promise<SessionCookies[]> {
  // Bước 1: Giải CAPTCHA
  const captchaToken = await capSolver.solveReCaptchaV2(loginUrl, siteKey);

  // Bước 2: Gửi token CAPTCHA để nhận cookie phiên
  const response = await axios.post(
    loginUrl,
    {
      'g-recaptcha-response': captchaToken,
    },
    {
      withCredentials: true,
      maxRedirects: 0,
      validateStatus: (status) => status < 400,
    }
  );

  // Bước 3: Trích xuất cookie từ phản hồi
  const setCookies = response.headers['set-cookie'] || [];
  const cookies: SessionCookies[] = setCookies.map((cookie: string) => {
    const [nameValue] = cookie.split(';');
    const [name, value] = nameValue.split('=');
    return {
      name: name.trim(),
      value: value.trim(),
      domain: new URL(loginUrl).hostname,
    };
  });

  return cookies;
}

async function extractWithPreAuth() {
  const loginUrl = 'https://example.com/verify';
  const targetUrl = 'https://example.com/protected-data';
  const siteKey = '6LcxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxABC';

  // Xác thực trước để nhận cookie phiên
  const sessionCookies = await preAuthenticateWithCaptcha(loginUrl, siteKey);

  console.log('Phiên đã thiết lập, tạo robot trích xuất...');

  // Tạo robot trích xuất bằng cách kế thừa phương thức
  // Lưu ý: Sử dụng setCookies() để truyền cookie phiên đã xác thực
  const robot = await extractor
    .create('Trình trích xuất đã xác thực')
    .setCookies(sessionCookies)
    .navigate(targetUrl)
    .wait(2000)
    .captureText({ content: '.protected-content' });

  // Chạy trích xuất
  const result = await robot.run({ timeout: 30000 });

  return result.data;
}

extractWithPreAuth().then(console.log).catch(console.error);

import { Scrape } from 'maxun-sdk';
import { CapSolverService } from './capsolver-service';

const capSolver = new CapSolverService({ apiKey: process.env.CAPSOLVER_API_KEY! });
const scraper = new Scrape({
  apiKey: process.env.MAXUN_API_KEY!,
  baseUrl: process.env.MAXUN_BASE_URL || 'https://app.maxun.dev/api/sdk',
});

interface ExtractionJob {
  url: string;
  siteKey?: string;
}

interface ExtractionResult {
  url: string;
  data: { markdown?: string; html?: string };
  captchaSolved: boolean;
  duration: number;
}

async function processJob(job: ExtractionJob): Promise<ExtractionResult> {
  const startTime = Date.now();

  let captchaSolved = false;

  // Giải CAPTCHA nếu có site key
  if (job.siteKey) {
    console.log(`Giải CAPTCHA cho ${job.url}...`);
    const token = await capSolver.solveReCaptchaV2(job.url, job.siteKey);
    captchaSolved = true;
    // Token sẽ được gửi để thiết lập phiên trước khi ghi chú
  }

  // Tạo và chạy robot ghi chú
  const robot = await scraper.create(`scraper-${Date.now()}`, job.url, {
    formats: ['markdown', 'html'],
  });

  const result = await robot.run({ timeout: 30000 });

  // Dọn dẹp robot sau khi sử dụng
  await robot.delete();

  return {
    url: job.url,
    data: {
      markdown: result.data.markdown,
      html: result.data.html,
    },
    captchaSolved,
    duration: Date.now() - startTime,
  };
}

async function runParallelExtractions(
  jobs: ExtractionJob[],
  concurrency: number = 5
): Promise<ExtractionResult[]> {
  const results: ExtractionResult[] = [];
  const chunks: ExtractionJob[][] = [];

  // Chia công việc thành các khối để kiểm soát độ đồng thời
  for (let i = 0; i < jobs.length; i += concurrency) {
    chunks.push(jobs.slice(i, i + concurrency));
  }

  for (const chunk of chunks) {
    const chunkResults = await Promise.all(chunk.map(processJob));
    results.push(...chunkResults);
  }

  return results;
}

// Ví dụ sử dụng
const jobs: ExtractionJob[] = [
  { url: 'https://site1.com/data', siteKey: '6Lc...' },
  { url: 'https://site2.com/data' },
  { url: 'https://site3.com/data', siteKey: '6Lc...' },
  // ... nhiều công việc hơn
];

runParallelExtractions(jobs, 5)
  .then((results) => {
    const solved = results.filter((r) => r.captchaSolved).length;
    console.log(`Hoàn thành ${results.length} trích xuất, giải được ${solved} CAPTCHA`);

    results.forEach((r) => {
      console.log(`${r.url}: ${r.duration}ms`);
    });
  })
  .catch(console.error);

async function solveWithRetry<T>(
  solverFn: () => Promise<T>,
  maxRetries: number = 3
): Promise<T> {
  let lastError: Error | undefined;

  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await solverFn();
    } catch (error) {
      lastError = error as Error;
      console.warn(`Lần thử ${attempt + 1} thất bại: ${lastError.message}`);

      // Tái thử theo cấp số nhân
      await new Promise((resolve) =>
        setTimeout(resolve, Math.pow(2, attempt) * 1000)
      );
    }
  }

  throw new Error(`Đã vượt quá số lần thử lại: ${lastError?.message}`);
}

// Sử dụng
const token = await solveWithRetry(() =>
  capSolver.solveReCaptchaV2(url, siteKey)
);

async function ensureSufficientBalance(minBalance: number = 1.0): Promise<void> {
  const balance = await capSolver.checkBalance();

  if (balance < minBalance) {
    throw new Error(
      `Số dư CapSolver không đủ: $${balance.toFixed(2)}. Vui lòng nạp tiền.`
    );
  }

  console.log(`Số dư CapSolver: $${balance.toFixed(2)}`);
}

// Kiểm tra số dư trước khi bắt đầu công việc trích xuất
await ensureSufficientBalance(5.0);

interface CachedToken {
  token: string;
  timestamp: number;
}

class TokenCache {
  private cache = new Map<string, CachedToken>();
  private ttlMs: number;

  constructor(ttlSeconds: number = 90) {
    this.ttlMs = ttlSeconds * 1000;
  }

  private getKey(domain: string, siteKey: string): string {
    return `${domain}:${siteKey}`;
  }

  get(domain: string, siteKey: string): string | null {
    const key = this.getKey(domain, siteKey);
    const cached = this.cache.get(key);

    if (!cached) return null;

    if (Date.now() - cached.timestamp > this.ttlMs) {
      this.cache.delete(key);
      return null;
    }

    return cached.token;
  }

  set(domain: string, siteKey: string, token: string): void {
    const key = this.getKey(domain, siteKey);
    this.cache.set(key, { token, timestamp: Date.now() });
  }
}

const tokenCache = new TokenCache(90);

async function getCachedOrSolve(
  url: string,
  siteKey: string
): Promise<string> {
  const domain = new URL(url).hostname;

  const cached = tokenCache.get(domain, siteKey);
  if (cached) {
    console.log('Sử dụng token đã lưu');
    return cached;
  }

  const token = await capSolver.solveReCaptchaV2(url, siteKey);
  tokenCache.set(domain, siteKey, token);

  return token;
}

import { Extract, Scrape, Crawl, Search } from 'maxun-sdk';
import { CapSolverService } from './capsolver-service';

// Đối với Maxun Cloud (app.maxun.dev)
const MAXUN_BASE_URL = 'https://app.maxun.dev/api/sdk';

// Đối với Maxun tự host (mặc định)
// const MAXUN_BASE_URL = 'http://localhost:8080/api/sdk';

// Cấu hình các module SDK Maxun
const extractor = new Extract({
  apiKey: process.env.MAXUN_API_KEY!,
  baseUrl: MAXUN_BASE_URL,
});
const scraper = new Scrape({
  apiKey: process.env.MAXUN_API_KEY!,
  baseUrl: MAXUN_BASE_URL,
});
const crawler = new Crawl({
  apiKey: process.env.MAXUN_API_KEY!,
  baseUrl: MAXUN_BASE_URL,
});
const searcher = new Search({
  apiKey: process.env.MAXUN_API_KEY!,
  baseUrl: MAXUN_BASE_URL,
});

// Cấu hình CapSolver
const capSolver = new CapSolverService({