Image CAPTCHA Guide — OCR and Text Challenges Explained

import base64
import requests
import time

def image_to_base64(image_path: str) -> str:
    """Read an image file and encode it as base64."""
    with open(image_path, "rb") as f:
        return base64.b64encode(f.read()).decode("utf-8")

def solve_image_captcha(
    api_key: str,
    image_path: str = None,
    image_base64: str = None,
    numeric: int = 0,
    min_len: int = 0,
    max_len: int = 0,
    phrase: int = 0,
    case_sensitive: int = 0,
) -> str:
    """
    Solve an image CAPTCHA using CaptchaAI (2Captcha-compatible API).

    Parameters:
      numeric: 0=any, 1=digits only, 2=letters only
      min_len: minimum answer length (0 = no constraint)
      max_len: maximum answer length (0 = no constraint)
      phrase: 1 if answer contains a space
      case_sensitive: 1 if answer is case-sensitive

    Returns the recognized text string.
    """
    if image_path:
        image_base64 = image_to_base64(image_path)
    if not image_base64:
        raise ValueError("Provide either image_path or image_base64")

    payload = {
        "key": api_key,
        "method": "base64",
        "body": image_base64,
        "json": 1,
    }
    # Optional hint parameters
    if numeric:
        payload["numeric"] = numeric
    if min_len:
        payload["min_len"] = min_len
    if max_len:
        payload["max_len"] = max_len
    if phrase:
        payload["phrase"] = phrase
    if case_sensitive:
        payload["regsense"] = case_sensitive

    r = requests.post("https://ocr.captchaai.com/in.php", data=payload, timeout=30)
    r.raise_for_status()
    result = r.json()
    if result.get("status") != 1:
        raise RuntimeError(f"Submit failed: {result}")
    task_id = result["request"]

    time.sleep(3)  # Image CAPTCHAs solve faster than behavioral types
    for _ in range(20):
        r = requests.get(
            "https://ocr.captchaai.com/res.php",
            params={"key": api_key, "action": "get", "id": task_id, "json": 1},
            timeout=30,
        )
        data = r.json()
        if data.get("status") == 1:
            return data["request"]  # Recognized text
        time.sleep(3)

    raise TimeoutError("Image CAPTCHA solve timed out")

from playwright.sync_api import sync_playwright
import base64

def solve_page_image_captcha(
    page_url: str,
    api_key: str,
    captcha_img_selector: str = "img#captcha, img[alt*='captcha'], img[src*='captcha']",
    input_selector: str = "input[name*='captcha'], input[id*='captcha']",
) -> None:
    """
    Full pipeline: load page → extract CAPTCHA image → solve → inject answer → submit.
    Adjust selectors to match the target site.
    """
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=True)
        page = browser.new_page()
        page.goto(page_url, wait_until="networkidle")

        # Get the CAPTCHA image as base64
        img_element = page.query_selector(captcha_img_selector)
        if not img_element:
            raise ValueError(f"CAPTCHA image not found with selector: {captcha_img_selector}")

        # Screenshot the image element directly (works even for dynamically generated images)
        img_bytes = img_element.screenshot()
        img_base64 = base64.b64encode(img_bytes).decode("utf-8")

        # Solve
        answer = solve_image_captcha(api_key, image_base64=img_base64)
        print(f"Recognized: {answer}")

        # Inject answer
        page.fill(input_selector, answer)

        # Submit
        page.click('button[type="submit"]')
        page.wait_for_load_state("networkidle")
        browser.close()

import re

def evaluate_math_captcha(solver_response: str) -> str:
    """If the solver returned a math expression, evaluate it."""
    # Check if the response looks like an expression: "3 + 7" or "12-4"
    expr = re.match(r'^(\d+)\s*([+\-*/])\s*(\d+)$', solver_response.strip())
    if expr:
        a, op, b = int(expr.group(1)), expr.group(2), int(expr.group(3))
        ops = {'+': a + b, '-': a - b, '*': a * b}
        return str(ops.get(op, solver_response))
    return solver_response  # Already evaluated or non-arithmetic

def report_bad_captcha(api_key: str, task_id: str) -> None:
    """Report an incorrect solve result. Usually earns a credit refund."""
    r = requests.get(
        "https://ocr.captchaai.com/res.php",
        params={"key": api_key, "action": "reportbad", "id": task_id, "json": 1},
        timeout=15,
    )
    # Returns {"status": 1, "request": "OK_REPORT_RECORDED"} on success

from PIL import Image
import io

def normalize_image(img_bytes: bytes) -> bytes:
    """Convert any image format to JPEG for maximum solver compatibility."""
    img = Image.open(io.BytesIO(img_bytes)).convert("RGB")
    buf = io.BytesIO()
    img.save(buf, format="JPEG", quality=95)
    return buf.getvalue()