कैप्चा को क्रॉली में कैपसॉल्वर इंटीग्रेशन के साथ हल करें

npm install crawlee playwright axios

yarn add crawlee playwright axios

import axios from 'axios';

const CAPSOLVER_API_KEY = 'अपना CAPSOLVER API KEY';

interface TaskResult {
    status: string;
    solution?: {
        gRecaptchaResponse?: string;
        token?: string;
    };
    errorDescription?: string;
}

class CapSolverService {
    private apiKey: string;
    private baseUrl = 'https://api.capsolver.com';

    constructor(apiKey: string = CAPSOLVER_API_KEY) {
        this.apiKey = apiKey;
    }

    async createTask(taskData: object): Promise<string> {
        const response = await axios.post(`${this.baseUrl}/createTask`, {
            clientKey: this.apiKey,
            task: taskData
        });

        if (response.data.errorId !== 0) {
            throw new Error(`कैपसॉल्वर त्रुटि: ${response.data.errorDescription}`);
        }

        return response.data.taskId;
    }

    async getTaskResult(taskId: string, maxAttempts = 60): Promise<TaskResult> {
        for (let i = 0; i < maxAttempts; i++) {
            await this.sleep(2000);

            const response = await axios.post(`${this.baseUrl}/getTaskResult`, {
                clientKey: this.apiKey,
                taskId
            });

            if (response.data.status === 'ready') {
                return response.data;
            }

            if (response.data.status === 'failed') {
                throw new Error(`कार्य विफल: ${response.data.errorDescription}`);
            }
        }

        throw new Error('कैप्चा समाधान के लिए प्रतीक्षा के बाद समय सीमा समाप्त हो गई');
    }

    private sleep(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 result = await this.getTaskResult(taskId);
        return result.solution?.gRecaptchaResponse || '';
    }

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

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

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

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

export const capSolver = new CapSolverService();

import { PlaywrightCrawler, Dataset } from 'crawlee';
import { capSolver } from './capsolver-service';

const RECAPTCHA_SITE_KEY = 'अपना साइट की';

const crawler = new PlaywrightCrawler({
    async requestHandler({ page, request, log }) {
        log.info(`प्रक्रिया कर रहे हैं ${request.url}`);

        // जांचें कि पृष्ठ में reCAPTCHA है या नहीं
        const hasRecaptcha = await page.$('.g-recaptcha');

        if (hasRecaptcha) {
            log.info('reCAPTCHA पाया गया, हल कर रहे हैं...');

            // पृष्ठ से साइट की प्राप्त करें
            const siteKey = await page.$eval(
                '.g-recaptcha',
                (el) => el.getAttribute('data-sitekey')
            ) || RECAPTCHA_SITE_KEY;

            // कैप्चा हल करें
            const token = await capSolver.solveReCaptchaV2(request.url, siteKey);

            // टोकन डालें - टेक्स्ट एरिया छिपा हुआ है, इसलिए जावास्क्रिप्ट का उपयोग करें
            await page.$eval('#g-recaptcha-response', (el: HTMLTextAreaElement, token: string) => {
                el.style.display = 'block';
                el.value = token;
            }, token);

            // फॉर्म भेजें
            await page.click('button[type="submit"]');
            await page.waitForLoadState('networkidle');

            log.info('reCAPTCHA सफलतापूर्वक हल कर दिया गया!');
        }

        // कैप्चा हल होने के बाद डेटा निकालें
        const title = await page.title();
        const content = await page.locator('body').innerText();

        await Dataset.pushData({
            title,
            content: content.slice(0, 1000)
        });
    },

    maxRequestsPerCrawl: 50,
    headless: true
});

await crawler.run(['https://example.com/protected-page']);

import { PlaywrightCrawler, Dataset } from 'crawlee';
import { capSolver } from './capsolver-service';

const crawler = new PlaywrightCrawler({
    async requestHandler({ page, request, log }) {
        log.info(`प्रक्रिया कर रहे हैं ${request.url}`);

        // reCAPTCHA v3 अदृश्य है, इसलिए स्क्रिप्ट द्वारा पहचानें
        const recaptchaScript = await page.$('script[src*="recaptcha/api.js?render="]');

        if (recaptchaScript) {
            log.info('reCAPTCHA v3 पाया गया, हल कर रहे हैं...');

            // स्क्रिप्ट स्रोत से साइट की निकालें
            const scriptSrc = await recaptchaScript.getAttribute('src') || '';
            const siteKeyMatch = scriptSrc.match(/render=([^&]+)/);
            const siteKey = siteKeyMatch ? siteKeyMatch[1] : '';

            if (siteKey) {
                // reCAPTCHA v3 हल करें
                const token = await capSolver.solveReCaptchaV3(
                    request.url,
                    siteKey,
                    'submit'
                );

                // जावास्क्रिप्ट का उपयोग करके छिपे इनपुट में टोकन डालें
                await page.$eval('input[name="g-recaptcha-response"]', (el: HTMLInputElement, token: string) => {
                    el.value = token;
                }, token);

                log.info('reCAPTCHA v3 टोकन डाल दिया गया!');
            }
        }

        // फॉर्म जमा करने या डेटा निकालने के बाद जारी रखें
        const title = await page.title();
        const url = page.url();

        await Dataset.pushData({ title, url });
    }
});

await crawler.run(['https://example.com/v3-protected']);

import { PlaywrightCrawler, Dataset } from 'crawlee';
import { capSolver } from './capsolver-service';

const crawler = new PlaywrightCrawler({
    async requestHandler({ page, request, log }) {
        log.info(`प्रक्रिया कर रहे हैं ${request.url}`);

        // Turnstile विजेट की जांच करें
        const hasTurnstile = await page.$('.cf-turnstile');

        if (hasTurnstile) {
            log.info('Cloudflare Turnstile पाया गया, हल कर रहे हैं...');

            // साइट की प्राप्त करें
            const siteKey = await page.$eval(
                '.cf-turnstile',
                (el) => el.getAttribute('data-sitekey')
            );

            if (siteKey) {
                // Turnstile हल करें
                const token = await capSolver.solveTurnstile(request.url, siteKey);

                // जावास्क्रिप्ट का उपयोग करके टोकन डालें (छिपा इनपुट)
                await page.$eval('input[name="cf-turnstile-response"]', (el: HTMLInputElement, token: string) => {
                    el.value = token;
                }, token);

                // फॉर्म भेजें
                await page.click('button[type="submit"]');
                await page.waitForLoadState('networkidle');

                log.info('Turnstile सफलतापूर्वक हल कर दिया गया!');
            }
        }

        // डेटा निकालें
        const title = await page.title();
        const content = await page.locator('body').innerText();

        await Dataset.pushData({
            title,
            content: content.slice(0, 500)
        });
    }
});

await crawler.run(['https://example.com/turnstile-protected']);

import { PlaywrightCrawler, Dataset } from 'crawlee';
import { capSolver } from './capsolver-service';

interface CaptchaInfo {
    type: 'recaptcha-v2' | 'recaptcha-v3' | 'turnstile' | 'none';
    siteKey: string | null;
}

async function detectCaptcha(page: any): Promise<CaptchaInfo> {
    // reCAPTCHA v2 की जांच करें
    const recaptchaV2 = await page.$('.g-recaptcha');
    if (recaptchaV2) {
        const siteKey = await page.$eval('.g-recaptcha', (el: Element) =>
            el.getAttribute('data-sitekey')
        );
        return { type: 'recaptcha-v2', siteKey };
    }

    // reCAPTCHA v3 की जांच करें
    const recaptchaV3Script = await page.$('script[src*="recaptcha/api.js?render="]');
    if (recaptchaV3Script) {
        const scriptSrc = await recaptchaV3Script.getAttribute('src') || '';
        const match = scriptSrc.match(/render=([^&]+)/);
        const siteKey = match ? match[1] : null;
        return { type: 'recaptcha-v3', siteKey };
    }

    // Turnstile की जांच करें
    const turnstile = await page.$('.cf-turnstile');
    if (turnstile) {
        const siteKey = await page.$eval('.cf-turnstile', (el: Element) =>
            el.getAttribute('data-sitekey')
        );
        return { type: 'turnstile', siteKey };
    }

    return { type: 'none', siteKey: null };
}

async function solveCaptcha(
    page: any,
    url: string,
    captchaInfo: CaptchaInfo
): Promise<void> {
    if (!captchaInfo.siteKey || captchaInfo.type === 'none') return;

    let token: string;

    switch (captchaInfo.type) {
        case 'recaptcha-v2':
            token = await capSolver.solveReCaptchaV2(url, captchaInfo.siteKey);
            // छिपा टेक्स्ट एरिया - जावास्क्रिप्ट का उपयोग करके मान डालें
            await page.$eval('#g-recaptcha-response', (el: HTMLTextAreaElement, t: string) => {
                el.style.display = 'block';
                el.value = t;
            }, token);
            break;

        case 'recaptcha-v3':
            token = await capSolver.solveReCaptchaV3(url, captchaInfo.siteKey);
            // छिपा इनपुट - जावास्क्रिप्ट का उपयोग करके मान डालें
            await page.$eval('input[name="g-recaptcha-response"]', (el: HTMLInputElement, t: string) => {
                el.value = t;
            }, token);
            break;

        case 'turnstile':
            token = await capSolver.solveTurnstile(url, captchaInfo.siteKey);
            // छिपा इनपुट - जावास्क्रिप्ट का उपयोग करके मान डालें
            await page.$eval('input[name="cf-turnstile-response"]', (el: HTMLInputElement, t: string) => {
                el.value = t;
            }, token);
            break;
    }
}

const crawler = new PlaywrightCrawler({
    async requestHandler({ page, request, log, enqueueLinks }) {
        log.info(`प्रक्रिया कर रहे हैं ${request.url}`);

        // कैप्चा का स्वचालित निर्धारण
        const captchaInfo = await detectCaptcha(page);

        if (captchaInfo.type !== 'none') {
            log.info(`${captchaInfo.type} पाया गया, हल कर रहे हैं...`);
            await solveCaptcha(page, request.url, captchaInfo);

            // यदि फॉर्म मौजूद है तो फॉर्म भेजें
            const submitBtn = await page.$('button[type="submit"], input[type="submit"]');
            if (submitBtn) {
कैपसॉल्वर के साथ क्रैली के एकीकरण कैसे करें

यहां कैपसॉल्वर के साथ क्रैली के एकीकरण के लिए एक उदाहरण है:

```typescript
import { PlaywrightCrawler, Dataset } from 'crawlee';
import { capSolver } from './capsolver-service';

const crawler = new PlaywrightCrawler({
    launchContext: {
        launchOptions: {
            // ब्राउज़र एक्सटेंशन लोड करें
            args: [
                `--disable-extensions-except=${path.resolve('./capsolver-extension')}`,
                `--load-extension=${path.resolve('./capsolver-extension')}`
            ],
            headless: false // एक्सटेंशन के लिए हेडलेस मोड आवश्यक नहीं है
        }
    },

    async requestHandler({ page, request, log, enqueueLinks }) {
        log.info(`प्रोसेसिंग ${request.url}`);

        // यहां आप कैपचा हल करने के लिए अपने कोड को जोड़ सकते हैं
        // अगर कैपचा हल हो गया है तो इसकी प्रतीक्षा करें
        const submitBtn = await page.$('button[type="submit"]');
        if (submitBtn) {
            await submitBtn.click();
            await page.waitForLoadState('networkidle');
        }

        log.info('कैपचा सफलतापूर्वक हल हो गया!');
    },

    // डेटा निकालें
    const title = await page.title();
    const url = page.url();
    const text = await page.locator('body').innerText();

    await Dataset.pushData({
        title,
        url,
        text: text.slice(0, 1000)
    });

    // आगे के ब्राउज़िंग के लिए जारी रखें
    await enqueueLinks();
    },

    maxRequestsPerCrawl: 100
});

await crawler.run(['https://example.com']);

async function submitRecaptchaToken(page: any, token: string): Promise<void> {
    // उत्तर टेक्स्ट क्षेत्र छिपा हुआ है - जावास्क्रिप्ट का उपयोग करके मान निर्धारित करें
    await page.$eval('#g-recaptcha-response', (el: HTMLTextAreaElement, token: string) => {
        el.style.display = 'block';
        el.value = token;
    }, token);

    // अगर विशेष अनुप्रयोगों में छिपा इनपुट मौजूद है तो इसे भी सेट करें
    try {
        await page.$eval('input[name="g-recaptcha-response"]', (el: HTMLInputElement, token: string) => {
            el.value = token;
        }, token);
    } catch (e) {
        // इनपुट मौजूद नहीं हो सकता है
    }

    // फॉर्म जमा करें
    await page.click('form button[type="submit"]');
}

async function submitTurnstileToken(page: any, token: string): Promise<void> {
    // जावास्क्रिप्ट का उपयोग करके छिपा इनपुट में टोकन सेट करें
    await page.$eval('input[name="cf-turnstile-response"]', (el: HTMLInputElement, token: string) => {
        el.value = token;
    }, token);

    // फॉर्म जमा करें
    await page.click('form button[type="submit"]');
}

import { PlaywrightCrawler } from 'crawlee';
import path from 'path';

const crawler = new PlaywrightCrawler({
    launchContext: {
        launchOptions: {
            // कैपसॉल्वर एक्सटेंशन लोड करें
            args: [
                `--disable-extensions-except=${path.resolve('./capsolver-extension')}`,
                `--load-extension=${path.resolve('./capsolver-extension')}`
            ],
            headless: false // एक्सटेंशन के लिए हेडलेस मोड आवश्यक है
        }
    },

    async requestHandler({ page, request, log }) {
        log.info(`प्रसंस्करण ${request.url}`);

        // एक्सटेंशन कैपचा स्वचालित रूप से हल करेगा
        // संभावित कैपचा हल होने के लिए प्रतीक्षा करें
        await page.waitForTimeout(5000);

        // आगे डेटा निकालें
        const title = await page.title();
        const content = await page.locator('body').innerText();

        console.log({ title, content });
    }
});

await crawler.run(['https://example.com/captcha-page']);

async function solveWithRetry(
    solverFn: () => Promise<string>,
    maxRetries = 3
): Promise<string> {
    for (let attempt = 0; attempt < maxRetries; attempt++) {
        try {
            return await solverFn();
        } catch (error) {
            if (attempt === maxRetries - 1) throw error;

            const delay = Math.pow(2, attempt) * 1000; // एक्स्पोनेंशियल बैकऑफ
            await new Promise(resolve => setTimeout(resolve, delay));
        }
    }
    throw new Error('अधिकतम पुन: प्रयास समाप्त');
}

// उपयोग
const token = await solveWithRetry(() =>
    capSolver.solveReCaptchaV2(url, siteKey)
);

import axios from 'axios';

async function checkBalance(apiKey: string): Promise<number> {
    const response = await axios.post('https://api.capsolver.com/getBalance', {
        clientKey: apiKey
    });

    return response.data.balance || 0;
}

// क्रैलर शुरू करने से पहले जांचें
const balance = await checkBalance(CAPSOLVER_API_KEY);
if (balance < 1) {
    console.warn('कैपसॉल्वर बैलेंस कम है! कृपया भरें।');
}

import { PlaywrightCrawler, Dataset } from 'crawlee';
import { capSolver } from './capsolver-service';

// एक ही डोमेन/कुंजी संयोजन के लिए हल किए गए टोकन कैश करें
const tokenCache = new Map<string, { token: string; timestamp: number }>();
const TOKEN_TTL = 90000; // 90 सेकंड

async function getCachedToken(
    url: string,
    siteKey: string,
    solverFn: () => Promise<string>
): Promise<string> {
    const cacheKey = `${new URL(url).hostname}:${siteKey}`;
    const cached = tokenCache.get(cacheKey);

    if (cached && Date.now() - cached.timestamp < TOKEN_TTL) {
        return cached.token;
    }

    const token = await solverFn();
    tokenCache.set(cacheKey, { token, timestamp: Date.now() });
    return token;
}

import { PlaywrightCrawler, ProxyConfiguration } from 'crawlee';

const proxyConfiguration = new ProxyConfiguration({
    proxyUrls: [
        'http://user:[email protected]:8080',
        'http://user:[email protected]:8080',
        'http://user:[email protected]:8080'
    ]
});

const crawler = new PlaywrightCrawler({
    proxyConfiguration,

    async requestHandler({ page, request, log, proxyInfo }) {
        log.info(`प्रॉक्सी का उपयोग कर रहे हैं: ${proxyInfo?.url}`);

        // आपके कैपचा समाधान और डेटा निकालने के लिए अपना कोड यहां रखें
    }
});

import { PlaywrightCrawler, Dataset, ProxyConfiguration } from 'crawlee';
import { capSolver } from './capsolver-service';

interface Product {
    name: string;
    price: string;
    url: string;
    image: string;
}

const proxyConfiguration = new ProxyConfiguration({
    proxyUrls: ['http://user:[email protected]:8080']
});

const crawler = new PlaywrightCrawler({
    proxyConfiguration,
    maxRequestsPerCrawl: 200,
    maxConcurrency: 5,

    async requestHandler({ page, request, log, enqueueLinks }) {
        log.info(`स्क्रैपिंग: ${request.url}`);

        // क्या कैपचा मौजूद है?
        const hasRecaptcha = await page.$('.g-recaptcha');
        const hasTurnstile = await page.$('.cf-turnstile');

        if (hasRecaptcha) {
            const siteKey = await page.$eval(
                '.g-recaptcha',
                (el) => el.getAttribute('data-sitekey')
            );

            if (siteKey) {
                log.info('रीकैपचा हल कर रहे हैं...');
                const token = await capSolver.solveReCaptchaV2(request.url, siteKey);

                // जावास्क्रिप्ट का उपयोग करके टोकन इंजेक्ट करें (छिपा तत्व)
                await page.$eval('#g-recaptcha-response', (el: HTMLTextAreaElement, t: string) => {
                    el.style.display = 'block';
                    el.value = t;
                }, token);
                await page.click('button[type="submit"]');
                await page.waitForLoadState('networkidle');
            }
        }

        if (hasTurnstile) {
            const siteKey = await page.$eval(
                '.cf-turnstile',
                (el) => el.getAttribute('data-sitekey')
            );

            if (siteKey) {
                log.info('टर्नस्टाइल हल कर रहे हैं...');
                const token = await capSolver.solveTurnstile(request.url, siteKey);

                // जावास्क्रिप्ट का उपयोग करके टोकन इंजेक्ट करें (छिपा तत्व)
                await page.$eval('input[name="cf-turnstile-response"]', (el: HTMLInputElement, t: string) => {
                    el.value = t;
                }, token);
                await page.click('button[type="submit"]');
                await page.waitForLoadState('networkidle');
            }
        }

        // प्लेयराइट लोकेटर का उपयोग करके उत्पाद डेटा निकालें
        const productCards = await page.locator('.product-card').all();
        const products: Product[] = [];

        for (const card of productCards) {
            products.push({
                name: await card.locator('.product-name').innerText().catch(() => ''),
                price: await card.locator('.product-price').innerText().catch(() => ''),
                url: await card.locator('a').getAttribute('href') || '',
                image: await card.locator('img').getAttribute('src') || ''
            });
        }

        if (products.length > 0) {
            await Dataset.pushData(products);
            log.info(`निकाले गए ${products.length} उत्पाद`);
        }

        // पृष्ठांत और श्रेणी लिंक एनक्यू करें
        await enqueueLinks({
            globs: ['**/products/**', '**/page/**', '**/category/**']
        });
    },

    failedRequestHandler({ request, log }) {
        log.error(`अनुरोध विफल: ${request.url}`);
    }
});

// स्क्रैपिंग शुरू करें
await crawler.run(['https://example-store.com/products']);

// परिणाम निर्यात करें
const dataset = await Dataset.open();
await dataset.exportToCSV('products.csv');

console.log('स्क्रैपिंग पूर्ण! परिणाम products.csv में संग्रहीत किए गए हैं');