Cara Menyelesaikan Captcha di EasySpider dengan Integrasi CapSolver

EasySpider adalah alat pengambilan data web yang kuat yang memungkinkan siapa pun untuk merancang dan menjalankan tugas otomatisasi browser tanpa menulis kode. Antarmuka berbasis flowchart yang intuitif membuatnya mudah diakses bagi non-programmer sementara masih memiliki kemampuan canggih untuk pengembang.

CapSolver melengkapi pengalaman otomatisasi EasySpider dengan menyediakan penyelesaian CAPTCHA yang mulus. Meskipun EasySpider mendukung berbagai metode pengenalan CAPTCHA, mengintegrasikan solusi berbasis AI dari CapSolver memastikan penyelesaian yang andal, cepat untuk reCAPTCHA, Cloudflare Turnstile, dan tantangan CAPTCHA lainnya.

Apa itu EasySpider?

EasySpider adalah alat pengambil data web visual yang gratis dan open-source. Berbeda dengan perpustakaan pengambil data tradisional yang memerlukan pengetahuan coding, EasySpider memungkinkan Anda merancang tugas secara visual dengan menunjuk dan mengklik elemen web.

Filosofi Inti

EasySpider beroperasi berdasarkan tiga prinsip dasar:

1. Desain Visual-First: Buat alur kerja otomatis yang kompleks melalui antarmuka flowchart yang intuitif
2. Akses Tanpa Kode: Merancang tugas secepat menggunakan Excel, terlepas dari pengalaman coding
3. Ekstensibilitas Penuh: Jalankan kode JavaScript, Python, dan pernyataan Selenium ketika diperlukan

Fitur Utama EasySpider

• Visual Task Designer: Antarmuka point-and-click untuk membuat alur kerja otomatis
• Cross-Platform: Tersedia untuk Windows, macOS, dan Linux
• Headless Mode: Jalankan tugas tanpa jendela browser yang terlihat
• Eksekusi Kode Kustom: Jalankan kode JavaScript dan Python dalam alur kerja
• Integrasi Selenium: Manipulasi browser langsung menggunakan pernyataan Selenium
• API Invocation: Panggil sistem dan layanan eksternal
• Eksekusi Command-Line: Jalankan tugas secara programmatic melalui CLI
• Tugas yang Dijadwalkan: Otomatisasi pengumpulan data berkala

Fitur Alur Kerja

Apa itu CapSolver?

CapSolver adalah layanan penyelesaian CAPTCHA terkemuka yang menyediakan solusi berbasis AI untuk melewati berbagai tantangan CAPTCHA. Dengan dukungan untuk berbagai jenis CAPTCHA dan waktu respons yang sangat cepat, CapSolver terintegrasi secara mulus ke dalam alur kerja otomatis.

Jenis CAPTCHA yang Didukung

• reCAPTCHA v2 (berbasis gambar & tidak terlihat)
• reCAPTCHA v3 & v3 Enterprise
• Cloudflare Turnstile
• Cloudflare 5-second Challenge
• AWS WAF CAPTCHA
• CAPTCHA dan mekanisme anti-bot lainnya yang umum digunakan

Mengapa Mengintegrasikan CapSolver dengan EasySpider?

Meskipun EasySpider memiliki dukungan CAPTCHA bawaan, mengintegrasikan CapSolver memberikan keuntungan signifikan:

1. Tingkat Keberhasilan yang Lebih Tinggi: Solusi berbasis AI dari CapSolver mencapai tingkat keberhasilan yang konsisten
2. Penyelesaian yang Lebih Cepat: Infrastruktur yang dioptimalkan menghasilkan token dengan cepat
3. Lingkup yang Lebih Luas: Dukungan untuk semua jenis CAPTCHA utama
4. Keandalan: Layanan berkelas perusahaan dengan uptime yang sangat baik
5. Skalabilitas: Menangani otomatisasi volume tinggi tanpa hambatan

Instalasi

Menginstal EasySpider

1. Unduh versi terbaru dari GitHub Releases
2. Pilih versi yang sesuai dengan platform Anda:
   • EasySpider_windows_x64.zip untuk Windows 64-bit
   • EasySpider_windows_x86.zip untuk Windows 32-bit
   • EasySpider_MacOS.dmg untuk macOS
   • EasySpider_Linux_x64.tar.gz untuk Linux
3. Ekstrak arsip dan jalankan EasySpider.exe (Windows) atau eksekusi yang sesuai

Catatan: Pastikan port 8084 tersedia untuk komunikasi antar proses.

Ketergantungan Python untuk Integrasi Kustom

Jika Anda merencanakan untuk menggunakan skrip bantuan CapSolver:

pip install requests

Membuat Utilitas CapSolver untuk EasySpider

Berikut adalah kelas utilitas CapSolver yang dapat digunakan kembali yang dirancang untuk alur kerja Python:

Layanan Dasar CapSolver

import requests
import time
from typing import Optional
from dataclasses import dataclass

CAPSOLVER_API_KEY = 'API_KEY_CAPSOLVER_ANDA'

@dataclass
class HasilTugas:
    status: str
    solusi: Optional[dict] = None
    deskripsi_kesalahan: Optional[str] = None


class CapSolverService:
    def __init__(self, kunci_api: str = CAPSOLVER_API_KEY):
        self.kunci_api = kunci_api
        self.url_pokok = 'https://api.capsolver.com'

    def buat_tugas(self, data_tugas: dict) -> str:
        respons = requests.post(
            f'{self.url_pokok}/buatTugas',
            json={
                'kunciClient': self.kunci_api,
                'tugas': data_tugas
            }
        )
        data = respons.json()

        if data.get('idKesalahan', 0) != 0:
            raise Exception(f"Kesalahan CapSolver: {data.get('deskripsiKesalahan')}")

        return data['idTugas']

    def dapatkan_hasil_tugas(self, id_tugas: str, maks_pengulangan: int = 60) -> HasilTugas:
        for _ in range(maks_pengulangan):
            time.sleep(2)

            respons = requests.post(
                f'{self.url_pokok}/dapatkanHasilTugas',
                json={
                    'kunciClient': self.kunci_api,
                    'idTugas': id_tugas
                }
            )
            data = respons.json()

            if data.get('status') == 'siap':
                return HasilTugas(
                    status='siap',
                    solusi=data.get('solusi')
                )

            if data.get('status') == 'gagal':
                raise Exception(f"Tugas gagal: {data.get('deskripsiKesalahan')}")

        raise Exception('Waktu tunggu solusi CAPTCHA habis')

    def selesaikan_recaptcha_v2(self, url_website: str, kunci_website: str) -> str:
        id_tugas = self.buat_tugas({
            'tipe': 'ReCaptchaV2TugasTanpaProxy',
            'urlWebsite': url_website,
            'kunciWebsite': kunci_website
        })

        hasil = self.dapatkan_hasil_tugas(id_tugas)
        return hasil.solusi.get('gRecaptchaResponse', '') if hasil.solusi else ''

    def selesaikan_turnstile(
        self,
        url_website: str,
        kunci_website: str,
        tindakan: Optional[str] = None,
        cdata: Optional[str] = None
    ) -> str:
        data_tugas = {
            'tipe': 'AntiTurnstileTugasTanpaProxy',
            'urlWebsite': url_website,
            'kunciWebsite': kunci_website
        }

        if tindakan or cdata:
            metadata = {}
            if tindakan:
                metadata['tindakan'] = tindakan
            if cdata:
                metadata['cdata'] = cdata
            data_tugas['metadata'] = metadata

        id_tugas = self.buat_tugas(data_tugas)
        hasil = self.dapatkan_hasil_tugas(id_tugas)
        return hasil.solusi.get('token', '') if hasil.solusi else ''


# Instansi global
capsolver = CapSolverService()

Metode Integrasi

EasySpider menawarkan beberapa cara untuk mengintegrasikan CapSolver. Pilih metode yang paling sesuai dengan kebutuhan Anda.

Metode 1: Tindakan Kustom dengan Injeksi JavaScript

EasySpider mendukung eksekusi JavaScript kustom dalam alur kerja Anda. Ini adalah metode integrasi yang paling sederhana.

Langkah 1: Buat tugas baru di EasySpider dan navigasi ke halaman yang dilindungi CAPTCHA

Langkah 2: Tambahkan node "Tindakan Kustom" dengan JavaScript berikut:

// Ekstrak sitekey dari elemen reCAPTCHA
var siteKey = document.querySelector('.g-recaptcha').getAttribute('data-sitekey');
var pageUrl = window.location.href;

// Simpan untuk digunakan di langkah berikutnya
window.captchaSiteKey = siteKey;
window.captchaPageUrl = pageUrl;

// Log untuk debugging
console.log('Site Key:', siteKey);
console.log('Page URL:', pageUrl);

Langkah 3: Gunakan fitur panggilan sistem eksternal EasySpider untuk memanggil skrip Python yang menyelesaikan CAPTCHA dan mengembalikan token

Langkah 4: Tambahkan node "Tindakan Kustom" lainnya untuk menyisipkan token:

// Token akan diteruskan dari skrip eksternal
var token = arguments[0];  // Diteruskan dari EasySpider

// Buat textarea respons terlihat dan atur token
document.getElementById('g-recaptcha-response').style.display = 'block';
document.getElementById('g-recaptcha-response').value = token;

// Jika ada fungsi callback, jalankan
if (typeof ___grecaptcha_cfg !== 'undefined') {
    var klien = ___grecaptcha_cfg.klien;
    if (klien) {
        Object.keys(klien).forEach(function(key) {
            var klien = klien[key];
            if (klien.callback) {
                klien.callback(token);
            }
        });
    }
}

Metode 1B: Turnstile (Tanpa Proxy) dengan EasySpider

Ini adalah alur kerja Turnstile tanpa proxy menggunakan node visual EasySpider. Ini tidak memerlukan proxy.

Langkah 1: Buat tugas baru dan navigasi ke halaman yang dilindungi Turnstile.

Langkah 2: Tambahkan tiga node Tindakan Kustom (mode kode = JavaScript) untuk menangkap metadata Turnstile:

// Judul node: TS_SiteKey
return document.querySelector('.cf-turnstile')?.getAttribute('data-sitekey') || '';

// Judul node: TS_Action (opsional)
return document.querySelector('.cf-turnstile')?.getAttribute('data-action') || '';

// Judul node: TS_Cdata (opsional)
return document.querySelector('.cf-turnstile')?.getAttribute('data-cdata') || '';

Langkah 3: Tambahkan node Panggil Perintah Sistem untuk menyelesaikan Turnstile dengan CapSolver:

python captcha_solver.py "{{current_url}}" "Field[\"TS_SiteKey\"]" "turnstile" "Field[\"TS_Action\"]" "Field[\"TS_Cdata\"]"

Berikan nama node ini sebagai Token sehingga Anda dapat merujuk outputnya sebagai Field["Token"].

Langkah 4: Tambahkan node Tindakan Kustom (JavaScript) untuk menyisipkan token:

var token = `Field["Token"]`;
var input = document.querySelectorAll('input[name="cf-turnstile-response"], input[name="turnstile-response"]');
input.forEach(function(el) {
    el.value = token;
    el.dispatchEvent(new Event('input', { bubbles: true }));
    el.dispatchEvent(new Event('change', { bubbles: true }));
});

Langkah 5: Klik tombol submit formulir (atau gunakan JS submit).

Catatan: Alur kerja Turnstile tanpa proxy bekerja di banyak situs, tetapi beberapa implementasi memvalidasi token terhadap IP solver. Jika ini terjadi, penyelesaian dengan proxy diperlukan.

Metode 3: Memodifikasi EasySpider's ExecuteStage

Untuk pengguna lanjutan, Anda dapat memperluas mesin eksekusi Python EasySpider secara langsung. Skrip easyspider_executestage.py menangani eksekusi tugas dan dapat dimodifikasi untuk mengintegrasikan CapSolver.

Lokasi: {EasySpider_Directory}/Code/easyspider_execututestage.py

Tambahkan layanan CapSolver ke konteks eksekusi:

# Tambahkan ke bagian impor di atas easyspider_executestage.py
import requests
import time

# Tambahkan kelas CapSolver
class CapSolverService:
    # ... (implementasi dari atas)
    pass

# Buat instansi global
capsolver = CapSolverService('API_KEY_CAPSOLVER_ANDA')

# Sekarang capsolver.solve_recaptcha_v2() tersedia dalam blok eval/exec

Kemudian dalam tugas EasySpider Anda, gunakan fitur "Eksekusi Kode Python":

# Dalam blok eksekusi Python EasySpider
site_key = driver.find_element_by_class_name('g-recaptcha').get_attribute('data-sitekey')
token = capsolver.solve_recaptcha_v2(url_sekarang, site_key)
driver.execute_script(f'''
    document.getElementById('g-recaptcha-response').value = `{token}`;
''')

Praktik Terbaik

1. Penanganan Kesalahan dengan Pengulangan

import time
from functools import wraps
from typing import Callable, TypeVar, Any

T = TypeVar('T')

def ulangi(maks_pengulangan: int = 3, backoff_eksponensial: bool = True):
    """Decorator untuk logika pengulangan dengan backoff eksponensial."""
    def dekorator(func: Callable[..., T]) -> Callable[..., T]:
        @wraps(func)
        def wrapper(*args: Any, **kwargs: Any) -> T:
            kesalahan_terakhir = None

            for percobaan in range(maks_pengulangan):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    kesalahan_terakhir = e

                    if percobaan < maks_pengulangan - 1:
                        delay = (2 ** percobaan) if backoff_eksponensial else 1
                        print(f'Percobaan {percobaan + 1} gagal, mencoba ulang dalam {delay}s...')
                        time.sleep(delay)

            raise kesalahan_terakhir

        return wrapper
    return dekorator


@ulangi(maks_pengulangan=3, backoff_eksponensial=True)
def selesaikan_dengan_pengulangan(capsolver, url: str, site_key: str) -> str:
    return capsolver.solve_recaptcha_v2(url, site_key)

2. Manajemen Saldo

def periksa_saldo(kunci_api: str) -> float:
    respons = requests.post(
        'https://api.capsolver.com/periksaSaldo',
        json={'kunciClient': kunci_api}
    )
    data = respons.json()
    return data.get('saldo', 0)


def main():
    saldo = periksa_saldo(CAPSOLVER_API_KEY)

    if saldo < 1:
        print('Peringatan: Saldo CapSolver rendah! Silakan isi ulang.')
    else:
        print(f'Saldo saat ini: ${saldo:.2f}')

3. Eksekusi Command-Line EasySpider

Jalankan tugas EasySpider dari command line:

# Eksekusi dasar
python easyspider_executestage.py --id [id_tugas] --read_type local --headless 1

# Dengan parameter lengkap
python easysider_executestage.py \
    --ids [0] \
    --server_address http://localhost:8074 \
    --config_folder "./" \
    --headless 1 \
    --read_type local

Alur Kerja Lengkap: Tugas EasySpider dengan CapSolver

Berikut cara membuat alur kerja EasySpider yang lengkap yang mencakup integrasi CapSolver:

Langkah 1: Rancang Tugas Anda di EasySpider

1. Jalankan EasySpider dan klik "Rancang Tugas"
2. Masukkan URL target (misalnya, https://www.google.com/recaptcha/api2/demo)
3. Tambahkan node alur kerja:
   • Buka Halaman: Navigasi ke URL
   • Tindakan Kustom: Jalankan JavaScript untuk mendeteksi CAPTCHA
   • Panggil Sistem: Panggil skrip Python dengan CapSolver
   • Tindakan Kustom: Sisipkan token
   • Klik Elemen: Kirim formulir
   • Kumpulkan Data: Ekstrak hasilnya

Langkah 2: Buat Skrip Bantuan CapSolver

Simpan ini sebagai captcha_solver.py di direktori EasySpider Anda:

#!/usr/bin/env python3
"""
Skrip Bantuan CapSolver untuk EasySpider
Penggunaan: python captcha_solver.py <url> <site_key> <tipe_captcha> [aksi] [cdata]
"""

import sys
import requests
import time

CAPSOLVER_API_KEY = 'API_KEY_CAPSOLVER_ANDA'

def solve_captcha(url, site_key, captcha_type='recaptcha_v2', action=None, cdata=None):
    """Selesaikan CAPTCHA dan kembalikan token."""

    if captcha_type == 'recaptcha_v2':
        task_type = 'ReCaptchaV2TaskProxyLess'
    elif captcha_type == 'turnstile':
        task_type = 'AntiTurnstileTaskProxyLess'
    else:
        raise ValueError(f'Tipe CAPTCHA tidak dikenal: {captcha_type}')

    # Buat tugas
    task = {
        'type': task_type,
        'websiteURL': url,
        'websiteKey': site_key
    }
    if captcha_type == 'turnstile' and (action or cdata):
        metadata = {}
        if action:
            metadata['action'] = action
        if cdata:
            metadata['cdata'] = cdata
        task['metadata'] = metadata

    response = requests.post(
        'https://api.capsolver.com/createTask',
        json={
            'clientKey': CAPSOLVER_API_KEY,
            'task': task
        }
    )
    data = response.json()

    if data.get('errorId', 0) != 0:
        raise Exception(f"Kesalahan: {data.get('errorDescription')}")

    task_id = data['taskId']

    # Poll hasil
    for _ in range(60):
        time.sleep(2)

        response = requests.post(
            'https://api.capsolver.com/getTaskResult',
            json={
                'clientKey': CAPSOLVER_API_KEY,
                'taskId': task_id
            }
        )
        data = response.json()

        if data.get('status') == 'ready':
            solution = data.get('solution', {})
            return solution.get('gRecaptchaResponse') or solution.get('token')

        if data.get('status') == 'failed':
            raise Exception(f"Gagal: {data.get('errorDescription')}")

    raise Exception('Waktu habis')


if __name__ == '__main__':
    if len(sys.argv) < 3:
        print('Penggunaan: python captcha_solver.py <url> <site_key> [tipe_captcha] [aksi] [cdata]')
        sys.exit(1)

    url = sys.argv[1]
    site_key = sys.argv[2]
    captcha_type = sys.argv[3] if len(sys.argv) > 3 else 'recaptcha_v2'
    action = sys.argv[4] if len(sys.argv) > 4 else None
    cdata = sys.argv[5] if len(sys.argv) > 5 else None

    try:
        token = solve_captcha(url, site_key, captcha_type, action, cdata)
        print(token)  # Output token untuk EasySpider menangkap
    except Exception as e:
        print(f'ERROR: {e}', file=sys.stderr)
        sys.exit(1)

Langkah 3: Konfigurasi EasySpider untuk Menggunakan Skrip

Dalam alur kerja EasySpider Anda, tambahkan node "Eksekusi Perintah Sistem":

python captcha_solver.py "{{current_url}}" "{{site_key}}" "recaptcha_v2"

Untuk Turnstile (tanpa proxy):

python captcha_solver.py "{{current_url}}" "{{site_key}}" "turnstile" "{{aksi}}" "{{cdata}}"

Output (token) dapat ditangkap dan digunakan dalam langkah injeksi JavaScript berikutnya.

Kesimpulan

Mengintegrasikan CapSolver dengan EasySpider menciptakan kombinasi yang kuat untuk otomatisasi web visual. Antarmuka alur kerja EasySpider yang intuitif membuat desain tugas aksesibel bagi semua orang, sementara CapSolver menangani tantangan CAPTCHA yang sebelumnya akan menghambat otomatisasi Anda.

Keuntungan utama integrasi ini:

• Visual + Canggih: Desain tugas secara visual sambil menangani CAPTCHA yang kompleks
• Banyak Metode Integrasi: Injeksi JavaScript, skrip Python, atau modifikasi langsung
• Semua Jenis CAPTCHA: reCAPTCHA v2, v3, Cloudflare Turnstile, tantangan, dan lainnya
• Siap Produksi: Penanganan kesalahan, ulang, dan manajemen saldo termasuk
• Multi-Platform: Berjalan di Windows, macOS, dan Linux

Baik Anda membangun pipeline ekstraksi data, sistem pemantauan, atau kerangka pengujian otomatis, kombinasi EasySpider + CapSolver memberikan pengalaman desain visual dan kemampuan penyelesaian CAPTCHA yang diperlukan untuk otomatisasi web modern.

Siap memulai? Daftar di CapSolver dan gunakan kode bonus EASYSPIDER untuk bonus tambahan 6% pada recharge pertama Anda!

FAQ

Apa itu EasySpider?

EasySpider adalah alat pengambilan data dan otomatisasi browser visual gratis dan open-source. Ini memungkinkan pengguna untuk merancang tugas otomatisasi melalui antarmuka alur kerja grafis tanpa menulis kode, sementara juga mendukung kode JavaScript, Python, dan pernyataan Selenium untuk kasus penggunaan lanjutan.

Bagaimana CapSolver terintegrasi dengan EasySpider?

CapSolver terintegrasi dengan EasySpider melalui beberapa metode: injeksi JavaScript dalam alur kerja EasySpider, skrip Python eksternal yang dipanggil melalui perintah sistem, atau modifikasi langsung pada mesin eksekusi Python EasySpider. Semua metode menggunakan API CapSolver untuk menyelesaikan CAPTCHA dan menyisipkan token ke halaman.

Apakah EasySpider menyelesaikan CAPTCHA sendiri?

EasySpider memiliki dukungan bawaan untuk beberapa skema pengenalan CAPTCHA dan kemampuan OCR. Namun, mengintegrasikan dengan CapSolver memberikan tingkat keberhasilan yang lebih tinggi, waktu penyelesaian yang lebih cepat, dan cakupan tipe CAPTCHA yang lebih luas untuk alur kerja otomatisasi produksi.

Jenis CAPTCHA apa yang dapat diselesaikan oleh CapSolver?

CapSolver mendukung berbagai jenis CAPTCHA termasuk reCAPTCHA v2, reCAPTCHA v3, Cloudflare Turnstile, AWS WAF, GeeTest v3/v4, dan banyak lagi.

Berapa biaya CapSolver?

CapSolver menawarkan harga kompetitif berdasarkan jenis dan volume CAPTCHA yang diselesaikan. Kunjungi capsolver.com untuk detail harga terkini. Gunakan kode EASYSPIDER untuk bonus 5% pada recharge pertama Anda.

Apakah EasySpider gratis untuk digunakan?

Ya, EasySpider sepenuhnya gratis dan open-source di bawah lisensi AGPL-3.0. Perangkat lunak ini memungkinkan penggunaan komersial gratis dan modifikasi. Deployment layanan jaringan harus menyediakan akses kode sumber kepada pengguna.

Bagaimana cara menemukan kunci situs CAPTCHA?

Kunci situs biasanya ditemukan dalam sumber HTML halaman:

• reCAPTCHA: atribut data-sitekey pada elemen .g-recaptcha
• Turnstile: atribut data-sitekey pada elemen .cf-turnstile

Bisakah saya menjalankan tugas EasySpider dari baris perintah?

Ya, EasySpider mendukung eksekusi dari baris perintah melalui easyspider_executestage.py. Ini memungkinkan integrasi dengan sistem lain, eksekusi tugas terjadwal, dan otomatisasi headless.

Platform apa yang didukung oleh EasySpider?

EasySpider tersedia untuk Windows (x64/x86), macOS, dan Linux. Unduh versi yang sesuai dari halaman Releases GitHub.

Bisakah saya menggunakan EasySpider dengan proxy?

Ya, EasySpider mendukung konfigurasi IP proxy dan pengalihan tunnel. Anda dapat mengatur proxy dalam pengaturan tugas atau melalui opsi peluncuran browser EasySpider.