Callback vs Polling: Pengiriman Hasil CaptchaAI

Task CAPTCHA sudah Anda kirim ke in.php — pertanyaannya sekarang: bagaimana cara tahu kapan hasilnya siap dipakai? CaptchaAI menyediakan dua jalur pengiriman hasil: polling, di mana kode Anda yang aktif bertanya ke res.php setiap beberapa detik, dan callback (webhook), di mana CaptchaAI yang mengirim hasil langsung ke server Anda begitu tantangan selesai diproses. Tidak ada jawaban yang benar secara mutlak — pilihannya bergantung pada volume task, apakah Anda punya server publik, dan seberapa besar latensi memengaruhi alur kerja Anda. Artikel ini membahas keduanya lengkap dengan contoh kode Python dan Node.js, tabel perbandingan, dan kapan sebaiknya menggabungkan keduanya.

Ringkasan Cepat: Polling vs Callback

Kalau Anda terburu-buru, tabel ini merangkum perbedaannya. Detail teknis dan contoh kode ada di bagian setelahnya.

Tip: kalau Anda tidak mau memilih salah satu, lihat bagian "Pendekatan Hybrid" di bawah — kombinasi callback dengan fallback polling adalah pola paling aman untuk sistem produksi.

Polling: Cara Paling Sederhana Mengambil Hasil

Secara default, aplikasi Anda mengecek endpoint res.php setiap 5 detik sampai hasilnya siap. Ini pendekatan paling sederhana untuk memulai — tidak perlu server tambahan atau konfigurasi jaringan apa pun. Contoh implementasinya di Python:

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 dan Kekurangan Polling

Untuk tim dengan volume rendah, kolom kanan tabel di atas bukan masalah besar. Tapi begitu task Anda mencapai ratusan per jam, permintaan yang terbuang mulai terasa di beban server dan waktu proses total.

Callback (Webhook): Notifikasi Otomatis dari CaptchaAI

Daripada bertanya berulang kali, Anda bisa memberi tahu CaptchaAI ke mana harus mengirim hasil begitu tantangan selesai diselesaikan. Caranya: sertakan parameter pingback berisi URL server Anda saat mengirim task. CaptchaAI akan mengirim hasilnya ke URL tersebut secara otomatis — tanpa Anda perlu polling sama sekali:

# 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

Begini bentuk permintaan yang CaptchaAI kirim ke server Anda — sebuah GET request berisi id dan code:

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

Contoh Server Callback dengan Flask (Python)

Server callback minimal cukup punya satu route yang menerima parameter id dan code, lalu menyimpannya supaya bisa diambil kapan saja:

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)

Contoh Server Callback dengan Express (Node.js)

Pola yang sama berlaku di Node.js — di produksi, ganti struktur Map di memori dengan database atau cache seperti Redis supaya hasil tidak hilang saat server restart:

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 dan Kekurangan Callback

Kapan Memilih Polling, Kapan Memilih Callback

Tidak ada jawaban universal — pilihan yang tepat bergantung pada volume task, infrastruktur yang sudah Anda miliki, dan seberapa penting latensi bagi sistem Anda.

Pilih Polling atau Callback?

Contoh Kasus: Tim Otomatisasi di Indonesia

Banyak tim otomatisasi Indonesia — agensi pemantauan harga e-commerce, freelancer scraping lewat kontrak gaya Upwork — mulai dengan polling karena setupnya cepat dan tanpa server tambahan. Begitu volume naik melewati ratusan CAPTCHA per jam, request yang terbuang mulai terasa di biaya operasional, dan tim biasanya pindah ke callback di server yang sama dengan pipeline scraping mereka — misalnya region AWS ap-southeast-1 (Singapura) atau GCP asia-southeast2 (Jakarta) untuk menjaga latensi rendah. Karena CaptchaAI menagih per thread, bukan per solve — BASIC mulai $15/bulan untuk 5 thread — pindah ke callback tidak menambah biaya solve, hanya mengurangi jumlah request ke server Anda.

Pendekatan Hybrid: Callback dengan Fallback Polling

Untuk sistem produksi, pola paling aman adalah menggabungkan keduanya: coba callback dulu, dan kalau hasilnya tidak kunjung datang dalam waktu tertentu, jatuhkan ke polling sebagai jaring pengaman. Ini melindungi Anda dari downtime webhook, masalah DNS, atau firewall yang tiba-tiba berubah:

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()

Pola ini banyak dipakai tim yang butuh kecepatan callback tapi tidak mau kehilangan hasil kalau ada gangguan jaringan sesaat.

Pertanyaan Umum

Berapa lama biasanya menunggu hasil kalau pakai polling?

Tergantung tipe CAPTCHA dan interval polling Anda. Dengan interval 5 detik seperti pada contoh di atas, Anda menambah jeda 0–5 detik di atas waktu penyelesaian sebenarnya. Untuk kebutuhan yang sangat sensitif terhadap latensi, callback lebih tepat karena hasil dikirim begitu tersedia.

Apakah URL callback wajib pakai HTTPS?

Tidak wajib, tapi disarankan. HTTP tetap berfungsi, namun kalau callback Anda menangani data sensitif seperti token, gunakan HTTPS supaya datanya terenkripsi saat transit.

Apakah polling menghabiskan jatah thread saya?

Tidak. Thread mengukur task CAPTCHA yang sedang diproses bersamaan, bukan jumlah permintaan res.php yang Anda kirim. Polling menambah panggilan API, tapi tidak menambah pemakaian thread di luar task yang sedang berjalan.

Bagaimana kalau server callback saya down saat hasil tiba?

CaptchaAI dapat mencoba ulang pengiriman callback beberapa kali. Sebagai jaring pengaman tambahan, server Anda tetap bisa melakukan polling manual ke res.php untuk task yang belum menerima callback — ini prinsip di balik pendekatan hybrid di atas.

Apakah polling cocok dipakai di AWS Lambda atau Cloud Functions?

Ya — polling justru pilihan yang lebih praktis di lingkungan serverless karena Anda tidak perlu menjalankan endpoint publik yang selalu aktif untuk menerima callback. Perhatikan saja batas waktu eksekusi function Anda supaya loop polling tidak terpotong sebelum hasil siap.

Panduan Terkait

• Format Respons API
• Panduan Setup dan Autentikasi API Key
• Panduan Memulai CaptchaAI