Strategi Solve CAPTCHA Gambar Multi-Karakter

CaptchaAI menyelesaikan CAPTCHA gambar dalam waktu di bawah 0.5 detik dengan tingkat keberhasilan tinggi — termasuk untuk huruf yang saling menempel, font campuran per karakter, dan noise latar belakang yang biasanya membuat OCR generik menyerah. Kuncinya bukan membangun model OCR sendiri, melainkan mengirim hint yang tepat (textinstructions, minLen, maxLen, regsense) bersama gambar ke API CaptchaAI. Bagian di bawah membahas strategi per jenis kerumitan, kapan praproses gambar benar-benar diperlukan, dan cara menangani kegagalan berulang saat sudah jalan di produksi.

Level Kerumitan CAPTCHA Gambar yang Sering Ditemui

Sebelum memilih strategi, kenali dulu pola kerumitan yang paling sering muncul di lapangan:

Dua baris terakhir — "Sulit" — adalah yang paling sering bikin script scraping berbasis OCR biasa gagal total, dan jadi fokus utama strategi di bawah.

Mengirim CAPTCHA Rumit ke API CaptchaAI

Untuk CAPTCHA multi-karakter, kirim gambar sebagai base64 ke endpoint in.php, lalu tambahkan hint yang relevan lewat parameter opsional seperti textinstructions, minLen, maxLen, atau regsense. Hint ini tidak wajib untuk CAPTCHA sederhana, tapi sangat membantu API mengenali pola pada gambar yang lebih rumit. Fungsi solve_complex_image di bawah jadi basis untuk semua strategi berikutnya — cukup panggil dengan hints yang berbeda sesuai jenis kerumitan yang Anda hadapi:

import requests
import base64
import time
import os

API_KEY = os.environ["CAPTCHAAI_API_KEY"]


def solve_complex_image(image_b64, hints=None):
    """Solve a complex multi-character image CAPTCHA."""
    payload = {
        "key": API_KEY,
        "method": "base64",
        "body": image_b64,
        "json": 1,
    }

    if hints:
        payload.update(hints)

    resp = requests.post(
        "https://ocr.captchaai.com/in.php",
        data=payload,
        timeout=30,
    )
    result = resp.json()

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

    task_id = result["request"]

    time.sleep(8)
    for _ in range(24):
        resp = requests.get("https://ocr.captchaai.com/res.php", params={
            "key": API_KEY,
            "action": "get",
            "id": task_id,
            "json": 1,
        }, timeout=15)
        data = resp.json()
        if data.get("status") == 1:
            return data["request"]
        if data["request"] != "CAPCHA_NOT_READY":
            raise RuntimeError(data["request"])
        time.sleep(5)

    raise TimeoutError("Solve timeout")

Strategi per Jenis Kerumitan

Tiga pola berikut paling sering bikin OCR biasa salah baca. Kirim hint yang sesuai dan CaptchaAI akan menyesuaikan cara membacanya.

Huruf yang Saling Menempel

Huruf yang saling menempel atau tumpang tindih adalah kasus paling sulit untuk OCR generik, tapi bukan masalah besar untuk CaptchaAI selama Anda memberi tahu rentang panjang karakter yang diharapkan:

def solve_connected_letters(image_path):
    """Solve CAPTCHA with connected/overlapping characters."""
    with open(image_path, "rb") as f:
        b64 = base64.b64encode(f.read()).decode("ascii")

    return solve_complex_image(b64, hints={
        "textinstructions": "Characters may be connected or overlapping",
        "minLen": 4,
        "maxLen": 8,
    })

Kombinasi Huruf Besar-Kecil dengan Noise

Saat CAPTCHA case-sensitive dan penuh noise latar belakang, set regsense=1 supaya huruf besar-kecil tidak disamakan, lalu jelaskan noise-nya lewat textinstructions supaya API tahu bagian mana yang harus diabaikan:

def solve_noisy_mixed(image_path):
    """Solve CAPTCHA with background noise and mixed case."""
    with open(image_path, "rb") as f:
        b64 = base64.b64encode(f.read()).decode("ascii")

    return solve_complex_image(b64, hints={
        "regsense": 1,         # Case-sensitive
        "language": 2,         # Latin characters
        "textinstructions": "Ignore background lines and noise",
    })

Font Berbeda di Tiap Karakter

Untuk CAPTCHA yang mengganti font di setiap karakter, textinstructions yang menyebutkan variasi font membantu API tidak terpaku pada satu bentuk huruf saja:

def solve_multi_font(image_path):
    """Solve CAPTCHA using multiple fonts per character."""
    with open(image_path, "rb") as f:
        b64 = base64.b64encode(f.read()).decode("ascii")

    return solve_complex_image(b64, hints={
        "textinstructions": "Each character may use a different font or style",
        "minLen": 5,
        "maxLen": 7,
    })

Praproses Gambar Sebelum Dikirim

CaptchaAI menangani sebagian besar distorsi secara native, jadi praproses bukan langkah wajib. Tapi untuk gambar yang sangat bising atau kontras rendah — termasuk hasil scraping dari koneksi mobile dengan bandwidth terbatas, kondisi yang lazim untuk worker yang jalan di lapangan — mengubah ke grayscale, menaikkan kontras, dan binarize sebelum encode base64 bisa menaikkan akurasi:

# preprocess.py
from PIL import Image, ImageFilter, ImageEnhance
import io
import base64


def preprocess_for_ocr(image_path):
    """Preprocess image to improve OCR accuracy."""
    img = Image.open(image_path)

    # Convert to grayscale
    img = img.convert("L")

    # Increase contrast
    enhancer = ImageEnhance.Contrast(img)
    img = enhancer.enhance(2.0)

    # Sharpen
    img = img.filter(ImageFilter.SHARPEN)

    # Binarize (threshold)
    threshold = 128
    img = img.point(lambda p: 255 if p > threshold else 0)

    # Encode back to base64
    buffer = io.BytesIO()
    img.save(buffer, format="PNG")
    return base64.b64encode(buffer.getvalue()).decode("ascii")

Strategi Retry dan Pelaporan Jawaban Salah

Kalau strategi pertama gagal, jangan langsung retry dengan hint yang sama. Fungsi solve_with_retry di bawah mencoba beberapa kombinasi hint secara berurutan — dari yang paling spesifik ke yang paling longgar — sebelum menyerah. Kalau jawaban yang dikembalikan tetap salah, panggil report_bad_answer dengan task_id yang sama supaya CaptchaAI bisa memakainya untuk memperbaiki model pada CAPTCHA sejenis berikutnya:

# retry_strategy.py


def solve_with_retry(image_b64, hints, max_retries=3):
    """Retry solving with fallback strategies."""
    strategies = [
        hints,                                          # Original hints
        {**hints, "textinstructions": ""},              # Without instructions
        {**hints, "numeric": 0, "regsense": 0},        # Relaxed constraints
    ]

    for i, strategy in enumerate(strategies[:max_retries]):
        try:
            result = solve_complex_image(image_b64, strategy)
            return {"text": result, "strategy": i, "success": True}
        except RuntimeError:
            continue

    return {"text": None, "strategy": -1, "success": False}


def report_bad_answer(task_id):
    """Report incorrect answer for quality feedback."""
    requests.get("https://ocr.captchaai.com/res.php", params={
        "key": API_KEY,
        "action": "reportbad",
        "id": task_id,
    }, timeout=10)

Skenario: Volume Tinggi di Tim Otomatisasi Indonesia

Ini pola yang umum di kalangan agensi pemantauan harga dan kontraktor lepas Indonesia yang menjalankan crawler terjadwal ke banyak situs sekaligus: setiap run bisa menemui ratusan CAPTCHA gambar multi-karakter dengan kombinasi kerumitan yang berbeda-beda. Karena CaptchaAI menagih per thread, bukan per solve, biaya tidak melonjak walau volume solve naik — paket BASIC ($15/bulan, 5 thread) sudah cukup untuk crawler skala kecil, sementara ADVANCE ($90/bulan, 50 thread) lebih pas untuk beberapa worker paralel yang jalan bersamaan.

Untuk tim yang worker-nya di-deploy di region seperti AWS ap-southeast-1 (Singapura) atau GCP asia-southeast2 (Jakarta), kombinasi praproses gambar dan report_bad_answer di atas membantu menjaga akurasi tetap tinggi walau kondisi jaringan bervariasi. Satu catatan penting: pastikan Anda hanya scraping data yang memang berhak Anda proses — UU PDP (UU 27/2022) dan UU ITE relevan kalau data yang diambil menyangkut informasi pribadi.

Mengatasi Masalah yang Sering Muncul

Pertanyaan Seputar Strategi CAPTCHA Gambar Multi-Karakter

Berapa lama waktu penyelesaian CAPTCHA gambar multi-karakter di CaptchaAI?

CaptchaAI menyelesaikan CAPTCHA gambar/OCR dalam waktu di bawah 0.5 detik dengan tingkat keberhasilan tinggi. Loop polling pada contoh kode di atas sengaja diberi jeda beberapa detik sebagai margin aman untuk kondisi jaringan yang kurang stabil — di praktiknya hasil biasanya sudah siap jauh sebelum iterasi polling pertama selesai.

Apakah ada batas karakter untuk CAPTCHA gambar yang bisa diproses?

CaptchaAI dapat menangani CAPTCHA hingga sekitar 20 karakter, meski mayoritas kasus di lapangan hanya 4-8 karakter. Untuk CAPTCHA yang jauh lebih panjang dari itu, sertakan minLen dan maxLen supaya API tahu rentang yang diharapkan.

Apakah parameter hint seperti textinstructions dan regsense berlaku sama di semua bahasa pemrograman?

Ya. Karena CaptchaAI adalah REST API biasa, hint yang sama berlaku persis sama baik Anda memanggilnya dari Python, Node.js, PHP, Go, Java, C#, Ruby, Rust, Kotlin, maupun langsung lewat curl/Bash — yang berubah hanya cara membuat HTTP request-nya, bukan payload-nya.

Apakah saya wajib praproses gambar sebelum mengirim ke API?

Tidak selalu. Praproses hanya diperlukan kalau hasil yang Anda dapat kurang akurat — misalnya untuk gambar yang sangat bising, resolusi rendah, atau kontras minim. CaptchaAI menangani sebagian besar distorsi secara native tanpa praproses tambahan.

Bagaimana cara menangani CAPTCHA yang berisi ekspresi matematika?

Aktifkan mode kalkulasi lewat parameter calc=1 supaya API mengembalikan hasil akhir (angka), bukan menuliskan ulang ekspresinya. Ini relevan untuk CAPTCHA yang menampilkan soal seperti "7 + 3 = ?" dan meminta jawaban numerik langsung.

Panduan Terkait

• Cara Meningkatkan Akurasi OCR CaptchaAI
• Panduan Praproses Gambar untuk Solve Rate Lebih Tinggi

Selesaikan CAPTCHA gambar yang paling rumit sekalipun — mulai dengan CaptchaAI.