Callback vs Polling: Pengiriman Hasil CaptchaAI

CaptchaAI menawarkan dua cara untuk menerima hasil CAPTCHA yang telah diselesaikan: polling (Anda bertanya berulang kali) dan callback (kami memberi tahu Anda). Keduanya bekerja dengan semua tipe CAPTCHA. Berikut kapan menggunakan masing-masing.

Polling (Default)

Lakukan polling endpoint res.php setiap 5 detik hingga hasilnya siap:

import requests
import time

API_KEY = "YOUR_API_KEY"

# Submit
resp = requests.get("https://ocr.captchaai.com/in.php", params={
    "key": API_KEY,
    "method": "userrecaptcha",
    "googlekey": "SITE_KEY",
    "pageurl": "https://example.com"
})
task_id = resp.text.split("|")[1]

# Poll
while True:
    time.sleep(5)
    result = requests.get("https://ocr.captchaai.com/res.php", params={
        "key": API_KEY,
        "action": "get",
        "id": task_id
    })
    if result.text == "CAPCHA_NOT_READY":
        continue
    if result.text.startswith("OK|"):
        token = result.text.split("|")[1]
        break

Kelebihan Polling

• Sederhana untuk diterapkan
• Tidak diperlukan infrastruktur server
• Bekerja di lingkungan apa pun (skrip, tanpa server, CLI)
• Tidak ada masalah firewall atau jaringan

Kontra Polling

• Membuang permintaan saat menunggu (satu permintaan setiap 5 detik)
• Menambahkan latensi — Anda memeriksanya setelah penyelesaian selesai, bukan secara instan
• Volume panggilan API lebih tinggi

Callback (Webhook)

Berikan URL pingback saat mengirimkan tugas. CaptchaAI akan melakukan POST hasil ke URL Anda ketika penyelesaian selesai:

# Submit with callback URL
resp = requests.get("https://ocr.captchaai.com/in.php", params={
    "key": API_KEY,
    "method": "userrecaptcha",
    "googlekey": "SITE_KEY",
    "pageurl": "https://example.com",
    "pingback": "https://your-server.com/captcha-callback"
})
task_id = resp.text.split("|")[1]
# No polling needed — result arrives at your callback URL

CaptchaAI mengirimkan permintaan GET ke URL panggilan balik Anda:

GET https://your-server.com/captcha-callback?id=TASK_ID&code=TOKEN

Server Callback (Flask Python)

from flask import Flask, request

app = Flask(__name__)
results = {}

@app.route("/captcha-callback")
def callback():
    task_id = request.args.get("id")
    token = request.args.get("code")
    results[task_id] = token
    return "OK", 200

@app.route("/get-result/<task_id>")
def get_result(task_id):
    token = results.get(task_id)
    if token:
        return {"status": "solved", "token": token}
    return {"status": "pending"}, 202

if __name__ == "__main__":
    app.run(port=8080)

Server Callback (Node.js Express)

const express = require("express");
const app = express();

const results = new Map();

app.get("/captcha-callback", (req, res) => {
  const { id, code } = req.query;
  results.set(id, code);
  res.send("OK");
});

app.get("/get-result/:taskId", (req, res) => {
  const token = results.get(req.params.taskId);
  if (token) {
    res.json({ status: "solved", token });
  } else {
    res.status(202).json({ status: "pending" });
  }
});

app.listen(8080);

Kelebihan Callback

• Notifikasi instan ketika penyelesaian selesai
• Tidak ada permintaan polling yang sia-sia
• Lebih efisien untuk volume tinggi
• Lebih baik untuk arsitektur async

Kekurangan Callback

• Membutuhkan server yang dapat diakses publik
• Perlu menangani keandalan webhook (retry, timeout)
• Infrastruktur lebih kompleks
• Perlu konfigurasi firewall/networking

Perbandingan

Kapan Menggunakan Masing-masing

Gunakan Polling Saat:

• Menjalankan skrip lokal atau tool CLI
• Membangun prototipe atau pengujian
• Di balik firewall tanpa server publik
• Memproses kurang dari 100 CAPTCHA per jam
• Menggunakan fungsi serverless (Lambda, Cloud Functions)

Gunakan Callback Saat:

• Memproses 100+ CAPTCHA per jam
• Menjalankan aplikasi web dengan server yang sudah tersedia
• Membangun sistem real-time yang mengutamakan latensi
• Ingin meminimalkan volume panggilan API
• Membangun microservice penyelesaian CAPTCHA

Pendekatan Hibrid

Gunakan callback dengan fallback polling:

import requests
import time

API_KEY = "YOUR_API_KEY"
CALLBACK_URL = "https://your-server.com/captcha-callback"

def solve_with_fallback(site_key, page_url):
    # Try callback first
    resp = requests.get("https://ocr.captchaai.com/in.php", params={
        "key": API_KEY,
        "method": "userrecaptcha",
        "googlekey": site_key,
        "pageurl": page_url,
        "pingback": CALLBACK_URL
    })
    task_id = resp.text.split("|")[1]

    # Wait for callback result (check your callback store)
    for _ in range(12):  # 60 seconds
        time.sleep(5)
        result = check_callback_store(task_id)
        if result:
            return result

    # Fallback to polling
    result = requests.get("https://ocr.captchaai.com/res.php", params={
        "key": API_KEY, "action": "get", "id": task_id
    })
    if result.text.startswith("OK|"):
        return result.text.split("|")[1]

    raise TimeoutError()

Pertanyaan Umum

Apakah URL callback memerlukan HTTPS?

HTTPS disarankan untuk keamanan, tetapi HTTP juga berfungsi. Jika callback Anda menangani data sensitif (token), gunakan HTTPS.

Bagaimana jika server callback saya down ketika hasilnya tiba?

CaptchaAI dapat mencoba ulang callback. Sebagai jaring pengaman, Anda selalu bisa kembali melakukan polling pada endpoint hasil.

Bisakah saya menggunakan URL callback yang sama untuk beberapa tugas?

Ya. Setiap callback menyertakan parameter id sehingga Anda dapat mencocokkan hasil dengan tugasnya.

Panduan Terkait

• Format Respons API
• Penyiapan dan Otentikasi Kunci API
• Panduan Memulai CaptchaAI