Koneksi Keep-Alive dan HTTP/2 untuk Panggilan API CAPTCHA Lebih Cepat

Setiap solve CAPTCHA melibatkan beberapa HTTP request: satu submit dan 3–10 polling. Tanpa reuse koneksi, setiap request membayar biaya TCP handshake dan negosiasi TLS baru — 100–300 ms per koneksi. Panduan ini menunjukkan cara menghilangkan overhead tersebut menggunakan persistent connection dan HTTP/2 multiplexing dengan CaptchaAI.

Mengapa Reuse Koneksi Itu Penting

Solve reCAPTCHA v2 yang tipikal memerlukan:

• 1 submit request ke in.php
• 4–6 polling request ke res.php
• Total: 5–7 HTTP request

Tanpa keep-alive:

• 5 × (TCP handshake ~50 ms + TLS ~100 ms) = overhead 750 ms

Dengan keep-alive:

• 1 × (TCP + TLS) + 4 × (~5 ms reuse) = overhead 170 ms

Penghematan: ~580 ms per solve. Dengan 10.000 solve/hari, itu berarti penghematan latensi sebesar 1,6 jam.

Python: Menggunakan requests.Session

Pustaka requests mendukung keep-alive secara default saat Anda menggunakan objek Session:

# keepalive_solver.py
import os
import time
import requests

API_KEY = os.environ.get("CAPTCHAAI_KEY", "YOUR_API_KEY")

# Create a session — reuses TCP connections across requests
session = requests.Session()
session.headers.update({"Connection": "keep-alive"})

def solve_captcha(sitekey, pageurl):
    """Solve reCAPTCHA v2 using a persistent connection."""
    # Submit — uses existing connection if available
    resp = session.get("https://ocr.captchaai.com/in.php", params={
        "key": API_KEY,
        "method": "userrecaptcha",
        "googlekey": sitekey,
        "pageurl": pageurl,
        "json": "1",
    })
    result = resp.json()

    if result.get("status") != 1:
        raise Exception(f"Submit failed: {result.get('request')}")

    task_id = result["request"]

    # Poll — reuses the same connection
    time.sleep(15)
    for _ in range(25):
        poll = session.get("https://ocr.captchaai.com/res.php", params={
            "key": API_KEY,
            "action": "get",
            "id": task_id,
            "json": "1",
        })
        poll_result = poll.json()

        if poll_result.get("status") == 1:
            return poll_result["request"]
        if poll_result.get("request") != "CAPCHA_NOT_READY":
            raise Exception(f"Error: {poll_result.get('request')}")

        time.sleep(5)

    raise Exception("Timeout")

# Solve multiple CAPTCHAs reusing the same connection
for i in range(5):
    token = solve_captcha(
        "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
        "https://www.google.com/recaptcha/api2/demo"
    )
    print(f"Solve {i+1}: {token[:30]}...")

Python: HTTP/2 dengan httpx

Untuk dukungan HTTP/2, gunakan httpx:

# http2_solver.py
import os
import time
import httpx

API_KEY = os.environ.get("CAPTCHAAI_KEY", "YOUR_API_KEY")
BASE_URL = "https://ocr.captchaai.com"

# HTTP/2 client with connection pooling
client = httpx.Client(http2=True, timeout=30.0)

def solve_captcha(sitekey, pageurl):
    """Solve using HTTP/2 multiplexed connections."""
    resp = client.get(f"{BASE_URL}/in.php", params={
        "key": API_KEY,
        "method": "userrecaptcha",
        "googlekey": sitekey,
        "pageurl": pageurl,
        "json": "1",
    })
    result = resp.json()

    if result.get("status") != 1:
        raise Exception(f"Submit failed: {result.get('request')}")

    task_id = result["request"]
    time.sleep(15)

    for _ in range(25):
        poll = client.get(f"{BASE_URL}/res.php", params={
            "key": API_KEY, "action": "get",
            "id": task_id, "json": "1",
        })
        poll_result = poll.json()

        if poll_result.get("status") == 1:
            return poll_result["request"]
        if poll_result.get("request") != "CAPCHA_NOT_READY":
            raise Exception(f"Error: {poll_result.get('request')}")

        time.sleep(5)

    raise Exception("Timeout")

# Multiple solves over a single HTTP/2 connection
for i in range(5):
    token = solve_captcha(
        "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
        "https://www.google.com/recaptcha/api2/demo"
    )
    print(f"Solve {i+1}: {token[:30]}...")

client.close()

JavaScript: Menggunakan Instance axios dengan Keep-Alive

// keepalive_solver.js
const axios = require('axios');
const http = require('http');
const https = require('https');

const API_KEY = process.env.CAPTCHAAI_KEY || 'YOUR_API_KEY';

// Create agents with keep-alive enabled
const httpAgent = new http.Agent({ keepAlive: true, maxSockets: 10 });
const httpsAgent = new https.Agent({ keepAlive: true, maxSockets: 10 });

// Axios instance with persistent connections
const api = axios.create({
  baseURL: 'https://ocr.captchaai.com',
  httpAgent,
  httpsAgent,
  timeout: 30000,
});

async function solveCaptcha(sitekey, pageurl) {
  // Submit — reuses connection
  const submit = await api.get('/in.php', {
    params: {
      key: API_KEY, method: 'userrecaptcha',
      googlekey: sitekey, pageurl, json: '1',
    },
  });

  if (submit.data.status !== 1) throw new Error(submit.data.request);
  const taskId = submit.data.request;

  // Poll — reuses same connection
  await new Promise(r => setTimeout(r, 15000));
  for (let i = 0; i < 25; i++) {
    const poll = await api.get('/res.php', {
      params: { key: API_KEY, action: 'get', id: taskId, json: '1' },
    });

    if (poll.data.status === 1) return poll.data.request;
    if (poll.data.request !== 'CAPCHA_NOT_READY') throw new Error(poll.data.request);
    await new Promise(r => setTimeout(r, 5000));
  }
  throw new Error('Timeout');
}

(async () => {
  for (let i = 0; i < 5; i++) {
    const token = await solveCaptcha(
      '6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-',
      'https://www.google.com/recaptcha/api2/demo'
    );
    console.log(`Solve ${i + 1}: ${token.slice(0, 30)}...`);
  }

  // Clean up agents
  httpAgent.destroy();
  httpsAgent.destroy();
})();

HTTP/2 vs HTTP/1.1 untuk Solve CAPTCHA

Untuk solve sekuensial (satu CAPTCHA dalam satu waktu), HTTP/1.1 keep-alive sudah cukup. Untuk solve paralel (beberapa CAPTCHA secara bersamaan), HTTP/2 multiplexing memberikan manfaat tambahan dengan berbagi satu koneksi.

Ukuran Connection Pool

Sesuaikan ukuran pool dengan tingkat concurrency Anda:

Pool terlalu besar membuang memori. Pool terlalu kecil memaksa koneksi baru, meniadakan manfaat keep-alive.

Pemecahan Masalah

Pertanyaan Umum

Apakah CaptchaAI mendukung HTTP/2?

Uji dengan curl --http2 https://ocr.captchaai.com/res.php untuk memverifikasi. Jika server menegosiasikan h2, client HTTP/2 Anda akan mendapat manfaatnya. Jika tidak, gunakan HTTP/1.1 keep-alive.

Haruskah saya menutup sesi setelah setiap batch?

Tidak. Biarkan sesi tetap terbuka di antara batch jika Anda menjalankan solve secara berkala. Tutup hanya saat aplikasi Anda dimatikan.

Apakah ini berfungsi dengan server proxy?

Ya, tapi proxy Anda juga harus mendukung keep-alive dan HTTP/2. Beberapa proxy SOCKS5 tidak mempertahankan persistent connection.

Artikel Terkait

• Circuit Breaker Pattern untuk API Call CAPTCHA
• Benchmarking Waktu Solve CAPTCHA

Langkah Selanjutnya

Kurangi overhead koneksi di setiap solve — dapatkan API key CaptchaAI Anda.