Smartproxy + CaptchaAI: Setup egress jaringan yang diotorisasi untuk Solve CAPTCHA

Menggabungkan Smartproxy dengan CaptchaAI intinya soal satu aturan: IP yang memuat halaman harus sama dengan IP yang mengirim form. Selama itu dipegang, token reCAPTCHA v2 atau Cloudflare Turnstile dari CaptchaAI diterima server target. Begitu gateway merotasi IP di tengah alur, token yang sah pun ditolak - dan Anda menghabiskan sore hari menyalahkan solver, padahal masalahnya di sesi jaringan.

Panduan ini menyusunnya dari sudut itu: memilih tipe jaringan, mengunci IP selama satu alur, dan menempatkan penyelesaian CAPTCHA di pipeline Anda. Contohnya memakai staging.example.com, jadi bisa diuji di lingkungan sendiri lebih dulu.

Dua sistem yang sering tertukar: jalur jaringan dan jalur token

Smartproxy mengurus satu hal - dari IP mana permintaan Anda keluar. CaptchaAI mengurus hal lain - mengubah tantangan CAPTCHA menjadi token yang valid. IP residensial yang bersih menurunkan frekuensi tantangan yang tampil, tetapi tidak menyelesaikan tantangan yang tetap muncul.

Titik pertemuannya ada dua. Pertama, sitekey dan pageurl yang dikirim ke in.php harus berasal dari halaman yang Anda muat lewat gateway. Kedua, token hasilnya harus dikirim balik dari sesi jaringan yang sama; kalau tidak, kegagalannya terlihat seperti "token tidak valid". CaptchaAI juga menerima parameter proxy opsional agar penyelesaian berjalan dari jalur keluar yang sama - pakai hanya untuk target yang mencocokkan IP ketat.

Tipe jaringan Smartproxy dan frekuensi CAPTCHA yang muncul

Mulai dari pool residensial; pindahkan ke pusat data hanya endpoint tanpa tantangan, misalnya API publik.

Setup Python: koneksi dasar dan fungsi penyelesaian

Dua hal perlu ada sejak awal: satu dictionary proxies untuk semua request halaman, dan satu fungsi solve dengan pola kanonik CaptchaAI - kirim ke in.php, simpan task ID, polling res.php, pakai token. Fungsi di bawah menangani reCAPTCHA v2 (userrecaptcha) dan Cloudflare Turnstile (turnstile) lewat satu argumen. Simpan kredensial dan YOUR_API_KEY di environment variable. Batas waktu 30 detik sengaja longgar: gateway residensial lebih lambat, dan batas yang terlalu ketat terbaca sebagai kegagalan target padahal hanya latensi.

import requests
import time

SMARTPROXY_USER = "spuser"
SMARTPROXY_PASS = "sppassword"
SMARTPROXY_HOST = "gate.smartproxy.com"
SMARTPROXY_PORT = 10001

CAPTCHAAI_KEY = "YOUR_API_KEY"
CAPTCHAAI_URL = "https://ocr.captchaai.com"

proxies = {
    "http": f"http://{SMARTPROXY_USER}:{SMARTPROXY_PASS}@{SMARTPROXY_HOST}:{SMARTPROXY_PORT}",
    "https": f"http://{SMARTPROXY_USER}:{SMARTPROXY_PASS}@{SMARTPROXY_HOST}:{SMARTPROXY_PORT}",
}


def fetch_page(url):
    return requests.get(url, proxies=proxies, timeout=30)


def solve_captcha(site_url, sitekey, captcha_type="recaptcha_v2"):
    submit_data = {
        "key": CAPTCHAAI_KEY,
        "pageurl": site_url,
        "json": 1,
    }

    if captcha_type == "turnstile":
        submit_data["method"] = "turnstile"
        submit_data["sitekey"] = sitekey
    else:
        submit_data["method"] = "userrecaptcha"
        submit_data["googlekey"] = sitekey

    resp = requests.post(f"{CAPTCHAAI_URL}/in.php", data=submit_data)
    data = resp.json()
    if data["status"] != 1:
        raise Exception(f"Submit failed: {data['request']}")

    task_id = data["request"]

    for _ in range(60):
        time.sleep(5)
        resp = requests.get(f"{CAPTCHAAI_URL}/res.php", params={
            "key": CAPTCHAAI_KEY,
            "action": "get",
            "id": task_id,
            "json": 1,
        })
        data = resp.json()
        if data["request"] == "CAPCHA_NOT_READY":
            continue
        if data["status"] == 1:
            return data["request"]
        raise Exception(f"Solve: {data['request']}")

    raise TimeoutError("Timeout")

Sticky session: menahan satu IP selama alur berlangsung

Bagian ini yang paling sering terlewat. Gateway berputar mengganti IP hampir di setiap request, sedangkan alur CAPTCHA butuh tiga langkah berurutan pada IP yang sama: muat halaman, selesaikan tantangan, kirim form. Smartproxy mengaturnya lewat sufiks username - -session-ID menetapkan sesi, -sessionduration-N menetapkan durasinya. Sepuluh menit cukup untuk alur satu halaman.

import random
import string


def get_sticky_proxy(session_duration_minutes=10):
    """Create a sticky session proxy (same IP for duration)."""
    session_id = "".join(random.choices(string.ascii_lowercase + string.digits, k=8))

    proxy_url = (
        f"http://{SMARTPROXY_USER}"
        f"-session-{session_id}"
        f"-sessionduration-{session_duration_minutes}"
        f":{SMARTPROXY_PASS}@{SMARTPROXY_HOST}:{SMARTPROXY_PORT}"
    )

    return {"http": proxy_url, "https": proxy_url}


# Use same IP for entire CAPTCHA workflow
sticky = get_sticky_proxy(session_duration_minutes=10)

# Page load
resp = requests.get("https://staging.example.com/qa-form", proxies=sticky)

# Solve CAPTCHA
token = solve_captcha("https://staging.example.com/qa-form", "SITEKEY_HERE")

# Submit with same IP
resp = requests.post(
    "https://target.com/submit",
    data={"g-recaptcha-response": token},
    proxies=sticky,
)

Penargetan negara ketika halaman berbeda per wilayah

Banyak target menampilkan markup, harga, bahkan sitekey berbeda tergantung negara asal IP. Kalau halaman dimuat dari IP Amerika Serikat tetapi form dikirim dari IP Jerman, sitekey-nya memang sudah lain. Kunci negara di awal alur.

# Smartproxy country targeting via username
def get_country_proxy(country_code):
    proxy_url = (
        f"http://{SMARTPROXY_USER}"
        f"-country-{country_code}"
        f":{SMARTPROXY_PASS}@{SMARTPROXY_HOST}:{SMARTPROXY_PORT}"
    )
    return {"http": proxy_url, "https": proxy_url}

# US proxy
us_proxy = get_country_proxy("us")

# UK proxy
uk_proxy = get_country_proxy("gb")

# Germany proxy
de_proxy = get_country_proxy("de")

Menjalankan Selenium melalui gateway Smartproxy

Untuk halaman yang merender CAPTCHA lewat JavaScript, browser tetap dibutuhkan. Chrome menerima --proxy-server tetapi tidak menerima username dan password di argumen itu, jadi autentikasi ditangani lewat Selenium Wire atau ekstensi kecil. Alurnya sama seperti versi requests, hanya sitekey diambil browser, bukan regex.

from selenium import webdriver
from selenium.webdriver.common.by import By


def create_smartproxy_driver(country=None, sticky_session=None):
    proxy_user = SMARTPROXY_USER
    if country:
        proxy_user += f"-country-{country}"
    if sticky_session:
        proxy_user += f"-session-{sticky_session}"

    proxy_url = f"{proxy_user}:{SMARTPROXY_PASS}@{SMARTPROXY_HOST}:{SMARTPROXY_PORT}"

    options = webdriver.ChromeOptions()
    options.add_argument(f"--proxy-server=http://{SMARTPROXY_HOST}:{SMARTPROXY_PORT}")
    options.add_argument("--window-size=1920,1080")

    # For authenticated proxies, use seleniumwire or extension
    return webdriver.Chrome(options=options)


def scrape_with_captcha(url, country="us"):
    session_id = "".join(random.choices(string.ascii_lowercase, k=8))
    driver = create_smartproxy_driver(country=country, sticky_session=session_id)

    try:
        driver.get(url)
        time.sleep(3)

        sitekey = driver.execute_script(
            "return document.querySelector('[data-sitekey]')?.getAttribute('data-sitekey')"
        )

        if sitekey:
            token = solve_captcha(url, sitekey)
            driver.execute_script(f"""
                document.querySelector('#g-recaptcha-response').value = '{token}';
            """)
            driver.find_element(By.CSS_SELECTOR, "form").submit()
            time.sleep(3)

        return driver.page_source

    finally:
        driver.quit()

Versi Node.js: axios plus https-proxy-agent

Pipeline yang sudah berjalan di Node.js tidak perlu dipindahkan ke Python. https-proxy-agent memasang gateway di level agent, sementara in.php dan res.php tetap request HTTP biasa. Halaman diambil lewat agent proxy, request penyelesaian dikirim langsung - pemisahan itu menjaga bandwidth berbayar tidak terpakai untuk lalu lintas API.

const axios = require("axios");
const HttpsProxyAgent = require("https-proxy-agent");

const CAPTCHAAI_KEY = "YOUR_API_KEY";

function getSmartproxyAgent(options = {}) {
  let user = "spuser";
  if (options.country) user += `-country-${options.country}`;
  if (options.session) user += `-session-${options.session}`;

  return new HttpsProxyAgent(
    `http://${user}:sppassword@gate.smartproxy.com:10001`
  );
}

async function scrapeWithCaptcha(url, sitekey) {
  const agent = getSmartproxyAgent({
    country: "us",
    session: `sess-${Date.now()}`,
  });

  // Fetch page through proxy
  const pageResp = await axios.get(url, { httpsAgent: agent });

  // Solve CAPTCHA via CaptchaAI (no proxy needed)
  const submitResp = await axios.post(
    "https://ocr.captchaai.com/in.php",
    null,
    {
      params: {
        key: CAPTCHAAI_KEY,
        method: "userrecaptcha",
        googlekey: sitekey,
        pageurl: url,
        json: 1,
      },
    }
  );

  const taskId = submitResp.data.request;

  // Poll for result
  for (let i = 0; i < 60; i++) {
    await new Promise((r) => setTimeout(r, 5000));

    const result = await axios.get("https://ocr.captchaai.com/res.php", {
      params: {
        key: CAPTCHAAI_KEY,
        action: "get",
        id: taskId,
        json: 1,
      },
    });

    if (result.data.request === "CAPCHA_NOT_READY") continue;
    if (result.data.status === 1) return result.data.request;
  }

  throw new Error("Timeout");
}

Menjalankan banyak URL paralel tanpa menghabiskan bandwidth

Paralelisme di sini punya dua batas: bandwidth Smartproxy yang ditagih per GB, dan jumlah thread CaptchaAI yaitu berapa CAPTCHA yang boleh diproses bersamaan. Lima worker pada contoh berikut pas dengan paket BASIC ($15/bulan, 5 thread); menaikkan max_workers melebihi jumlah thread hanya memperpanjang antrean. Beri setiap worker sesi miliknya sendiri - session ID yang dipakai bersama berarti IP yang dipakai bersama.

from concurrent.futures import ThreadPoolExecutor, as_completed


def process_url(url):
    session_id = "".join(random.choices(string.ascii_lowercase, k=8))
    proxy = get_sticky_proxy(10)

    try:
        resp = requests.get(url, proxies=proxy, timeout=30)

        # Check if CAPTCHA is present (simplified detection)
        if "data-sitekey" in resp.text:
            import re
            match = re.search(r'data-sitekey="([^"]+)"', resp.text)
            if match:
                sitekey = match.group(1)
                token = solve_captcha(url, sitekey)
                return {"url": url, "status": "solved", "token": token[:30]}

        return {"url": url, "status": "no_captcha"}

    except Exception as e:
        return {"url": url, "status": "error", "error": str(e)}


urls = [
    "https://site1.com/page",
    "https://site2.com/page",
    "https://site3.com/page",
]

with ThreadPoolExecutor(max_workers=5) as executor:
    futures = {executor.submit(process_url, u): u for u in urls}

    for future in as_completed(futures):
        result = future.result()
        print(f"[{result['status']}] {result['url']}")

Biaya dan latensi: bandwidth gateway vs thread CaptchaAI

Untuk freelancer scraping dan agensi price monitoring di Indonesia yang menagih per proyek, dua komponen biaya ini berbeda perilaku. Bandwidth gateway naik mengikuti ukuran halaman - satu situs berat gambar menghabiskan kuota lebih cepat daripada seribu halaman teks. Sisi CaptchaAI kebalikannya: penagihan berbasis thread, bukan per penyelesaian, dengan solve tanpa batas per thread selama bulan berjalan, sehingga biayanya datar begitu paket dipilih.

Untuk kebanyakan proyek satu klien, BASIC ($15/bulan, 5 thread) atau STANDARD ($30/bulan, 15 thread) sudah memadai; pipeline sepanjang hari dengan puluhan worker paralel baru masuk ke ADVANCE ($90/bulan, 50 thread). Harga selalu dalam USD.

Kalau worker berjalan di AWS ap-southeast-1 (Singapura) atau ap-southeast-3 (Jakarta), rutenya tetap melewati gateway Smartproxy; untuk target di luar Asia, mendekatkan worker ke target lebih berpengaruh daripada mengganti pool IP. Catatan kepatuhan lokal: UU Pelindungan Data Pribadi (UU 27/2022) menegaskan batasnya - ambil hanya data yang Anda berwenang memprosesnya.

Checklist sebelum dijalankan di produksi

• Kredensial Smartproxy dan API key CaptchaAI dibaca dari environment variable.
• Setiap worker punya session ID unik, -sessionduration melampaui alur terpanjang.
• Negara dikunci di awal alur sampai form terkirim.
• Percobaan ulang jaringan memakai jeda yang meningkat eksponensial.
• Pemakaian bandwidth dipantau harian.

Masalah umum dan cara memperbaikinya

Pertanyaan yang sering muncul

Apakah CaptchaAI harus memakai proxy yang sama dengan scraper saya?

Tidak selalu. Untuk sebagian besar target, penyelesaian tanpa proxy sudah diterima.

Kenapa token reCAPTCHA v2 saya ditolak padahal penyelesaiannya sukses?

Paling sering karena IP berubah antara pemuatan halaman dan pengiriman form. Kedua, token kedaluwarsa: token reCAPTCHA v2 berlaku sekitar dua menit, jadi kirim segera setelah diterima.

Berapa thread CaptchaAI untuk lima worker paralel?

Minimal lima - satu thread menampung satu CAPTCHA. BASIC ($15/bulan) memberi 5 thread; kalau worker sering menunggu, naikkan ke STANDARD ($30/bulan, 15 thread).

Bagaimana kalau situs uji saya memakai hCaptcha?

Belum. hCaptcha dan FunCaptcha tidak didukung, dan GeeTest v4 masih berstatus segera hadir. Yang relevan untuk alur ini: reCAPTCHA v2, reCAPTCHA v3, Cloudflare Turnstile, dan GeeTest v3.

Apakah IP Indonesia lebih baik daripada IP Singapura untuk target lokal?

Untuk situs yang membedakan konten per wilayah, ya - pakai penargetan negara agar halaman yang Anda muat sama dengan yang dilihat pengguna di sana. Untuk situs global, konsistensi sesi jauh lebih menentukan.

Panduan terkait

• Integrasi Bright Data dengan CaptchaAI
• Rotasi egress jaringan yang diotorisasi
• Kualitas jalur keluar dan tingkat keberhasilan

Pasangkan gateway Smartproxy dengan CaptchaAI - ambil API key lalu uji satu alur penuh.