Tipos de CAPTCHA personalizados: enviando desafios incomuns para CaptchaAI

Slider, quebra-cabeça, rotação de imagem, áudio ou um widget proprietário escrito em JavaScript: quando o desafio não é um reCAPTCHA nem uma imagem de texto comum, existe um caminho único que cobre quase todos os casos. Você captura o desafio como imagem, envia essa imagem à CaptchaAI junto com instruções em texto que descrevem o que precisa ser resolvido e recebe de volta a resposta — um número, um deslocamento ou um trecho de texto. Este guia mostra como aplicar esse padrão a cada formato fora do padrão, do controle deslizante ao áudio, e como detectar automaticamente qual tipo você está enfrentando.

Os formatos cobertos aqui seguem quatro estratégias:

• slider e quebra-cabeça, resolvidos pela posição do arraste;
• rotação de imagem, resolvida pelo ângulo de giro;
• ordem de cliques e widgets próprios, resolvidos por instruções descritivas;
• áudio, resolvido por transcrição.

Uma nota de escopo antes de começar: os exemplos assumem um ambiente autorizado — QA, staging ou automação sobre sistemas que você controla. Ao coletar dados de terceiros, considere as obrigações da LGPD e trate CAPTCHAs apenas em fluxos que você tem permissão para automatizar.

Como identificar um CAPTCHA fora do padrão

O primeiro passo é classificar o desafio. Cada formato pede uma instrução de texto diferente, mas todos passam pela mesma função de envio.

O método universal: imagem mais instruções em texto

A base de tudo é uma única função: capture o desafio, converta para base64 e envie ao endpoint de imagem/OCR com um campo textinstructions que diz, em linguagem natural, o que a CaptchaAI deve devolver. Quanto mais específica a instrução ("retorne apenas o número"), mais direto e utilizável fica o resultado.

import requests
import base64
import time
import os

API_KEY = os.environ["CAPTCHAAI_API_KEY"]


def solve_custom_captcha(image_b64, instructions):
    """Solve any visual CAPTCHA using image + text instructions."""
    resp = requests.post("https://ocr.captchaai.com/in.php", data={
        "key": API_KEY,
        "method": "base64",
        "body": image_b64,
        "textinstructions": instructions,
        "json": 1,
    }, timeout=30)

    result = resp.json()
    if result.get("status") != 1:
        raise RuntimeError(result.get("request"))

    task_id = result["request"]

    time.sleep(10)
    for _ in range(30):
        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")

Todas as seções seguintes reaproveitam essa função — o que muda é apenas a captura de tela e a frase de instrução. Duas regras deixam a resposta utilizável:

• descreva o formato de saída esperado (número, coordenada ou texto);
• feche a instrução com "retorne apenas ..." para evitar descrições longas.

CAPTCHA de slider: descubra o deslocamento do arraste

Nos desafios de controle deslizante, você precisa saber quantos pixels arrastar. Peça exatamente esse número na instrução e depois reproduza o movimento com o Selenium.

# slider_captcha.py
from selenium.webdriver.common.by import By
from selenium.webdriver.common.action_chains import ActionChains


def solve_slider_captcha(driver, captcha_selector):
    """Screenshot slider CAPTCHA and solve via CaptchaAI."""
    captcha = driver.find_element(By.CSS_SELECTOR, captcha_selector)
    image_b64 = captcha.screenshot_as_base64

    result = solve_custom_captcha(
        image_b64,
        "What pixel position should the slider be dragged to? "
        "Return only the X offset number."
    )

    try:
        offset = int(result)
    except ValueError:
        return False

    # Drag slider to position
    slider = driver.find_element(By.CSS_SELECTOR, ".slider-handle")
    ActionChains(driver).click_and_hold(slider).move_by_offset(offset, 0).release().perform()

    return True

Em um cenário de QA sobre staging.example.com, vale registrar o deslocamento retornado e comparar com a posição real do widget para calibrar as instruções.

CAPTCHA de rotação: acerte a orientação da imagem

Aqui a resposta é um ângulo. Peça os graus e converta em cliques no botão de rotação — a maioria dos widgets gira 90 graus por clique.

# rotation_captcha.py


def solve_rotation_captcha(driver, captcha_selector):
    """Solve rotation CAPTCHA."""
    captcha = driver.find_element(By.CSS_SELECTOR, captcha_selector)
    image_b64 = captcha.screenshot_as_base64

    result = solve_custom_captcha(
        image_b64,
        "How many degrees should this image be rotated clockwise "
        "to be in the correct upright orientation? Return only the number."
    )

    try:
        degrees = int(result)
    except ValueError:
        return False

    # Click rotation button the correct number of times
    rotate_btn = driver.find_element(By.CSS_SELECTOR, ".rotate-button")
    clicks = degrees // 90  # Each click rotates 90 degrees

    for _ in range(clicks):
        rotate_btn.click()
        time.sleep(0.3)

    return True

CAPTCHA de ordem: clique na sequência certa

Alguns desafios pedem cliques em uma ordem específica. Peça a sequência como números separados por vírgula e clique nos elementos correspondentes.

# order_captcha.py


def solve_order_captcha(driver, captcha_selector, item_selector):
    """Solve click-in-order CAPTCHA."""
    captcha = driver.find_element(By.CSS_SELECTOR, captcha_selector)
    image_b64 = captcha.screenshot_as_base64

    result = solve_custom_captcha(
        image_b64,
        "What is the correct order? Return as comma-separated "
        "numbers (1-indexed) representing positions left-to-right, top-to-bottom."
    )

    # Parse order
    try:
        order = [int(x.strip()) for x in result.split(",")]
    except ValueError:
        return False

    # Click items in order
    items = driver.find_elements(By.CSS_SELECTOR, item_selector)
    for idx in order:
        if 1 <= idx <= len(items):
            items[idx - 1].click()
            time.sleep(0.5)

    return True

CAPTCHA de áudio: transcreva o desafio sonoro

Quando o site oferece uma alternativa em áudio, baixe o arquivo, converta para base64 e envie com uma instrução de transcrição. O suporte a áudio depende do desafio, então valide a resposta antes de confiar nela.

# audio_captcha.py
import requests


def solve_audio_captcha(audio_url):
    """Download and solve an audio CAPTCHA."""
    # Download audio
    resp = requests.get(audio_url, timeout=30)
    audio_b64 = base64.b64encode(resp.content).decode("ascii")

    # Submit as image with instructions
    # CaptchaAI may support audio via the base64 method
    result = solve_custom_captcha(
        audio_b64,
        "This is an audio CAPTCHA. Transcribe the spoken characters."
    )
    return result

Widgets totalmente personalizados

Para componentes proprietários em que você não conhece o formato de antemão, a lógica é sempre a mesma:

• capture o widget inteiro como imagem;
• leia qualquer instrução visível na própria página e repasse esse contexto à CaptchaAI;
• tente escrever a resposta no campo de entrada — ou, se não houver um, injete o valor via JavaScript.

# custom_widget.py
from selenium import webdriver
from selenium.webdriver.common.by import By


def handle_custom_widget(driver, widget_selector):
    """Handle an unknown custom CAPTCHA widget."""

    # Step 1: Screenshot the entire widget
    widget = driver.find_element(By.CSS_SELECTOR, widget_selector)
    image_b64 = widget.screenshot_as_base64

    # Step 2: Get any visible instructions
    try:
        instructions_el = widget.find_element(By.CSS_SELECTOR, ".instructions, .prompt, p")
        visible_instructions = instructions_el.text
    except Exception:
        visible_instructions = "Solve this CAPTCHA"

    # Step 3: Submit with descriptive instructions
    result = solve_custom_captcha(
        image_b64,
        f"CAPTCHA instructions: {visible_instructions}. "
        f"Return the answer text."
    )

    # Step 4: Try to submit result
    try:
        input_el = widget.find_element(By.CSS_SELECTOR, "input")
        input_el.clear()
        input_el.send_keys(result)
    except Exception:
        # No input — try clicking based on result
        driver.execute_script("""
            var input = document.querySelector('input[name*="captcha"]');
            if (input) input.value = arguments[0];
        """, result)

    return result

Detecção automática do tipo de CAPTCHA

Quando um mesmo fluxo pode encontrar formatos diferentes, vale automatizar a triagem. Um detector simples resolve dois problemas:

• inspeciona o HTML da página e identifica qual desafio está presente;
• roteia cada caso para a função de resolução correta, sem intervenção manual.

# detector.py
import re


def detect_captcha_type(page_html):
    """Detect which CAPTCHA type is on a page."""
    checks = {
        "recaptcha_v2": r'data-sitekey.*g-recaptcha',
        "recaptcha_v3": r'recaptcha/api\.js\?render=',
        "turnstile": r'cf-turnstile|challenges\.cloudflare\.com/turnstile',
        "geetest": r'gt\b.*challenge|geetest',
        "bls": r'method.*bls|bls-captcha',
        "image_text": r'captcha.*\.(png|jpg|gif|jpeg)',
        "slider": r'slider.*captcha|slide.*verify',
        "audio": r'audio.*captcha|captcha.*audio',
    }

    detected = []
    for captcha_type, pattern in checks.items():
        if re.search(pattern, page_html, re.IGNORECASE):
            detected.append(captcha_type)

    return detected if detected else ["unknown"]

Solução de problemas

Perguntas frequentes

O CaptchaAI resolve qualquer tipo de CAPTCHA?

Não existe serviço que resolva literalmente qualquer CAPTCHA. A CaptchaAI cobre nativamente as principais famílias — reCAPTCHA v2/v3, Cloudflare Turnstile e Challenge, GeeTest v3, imagem/OCR, grade de imagens e BLS. Para formatos realmente novos, o método de imagem mais instruções em texto é a abordagem mais ampla, porque descreve o desafio em linguagem natural em vez de depender de um parser específico.

Como faço a instrução retornar apenas o valor?

Seja explícito: termine a frase com "retorne apenas o número" ou "retorne apenas o texto, sem explicação". O solucionador tende a devolver exatamente o que você pediu; instruções vagas produzem descrições em vez de valores utilizáveis.

Dá para transcrever CAPTCHA de áudio pelo mesmo endpoint?

Sim, pelo mesmo campo base64. Baixe o arquivo, converta para base64 e envie com uma instrução como "transcreva os caracteres falados". Como o suporte a áudio varia conforme o desafio, valide a resposta antes de confiar nela em produção.

Quais tipos não estão disponíveis atualmente?

O hCaptcha e o FunCaptcha (Arkose Labs) não fazem parte da lista atual. O GeeTest v3 está disponível; o GeeTest v4 aparece como "em breve" e ainda não entrou em produção. Já CaptchaFox, Friendly Captcha e Lemin estão em beta.

Guias relacionados

• Estratégias para resolver CAPTCHAs de múltiplos caracteres
• Boas práticas de codificação Base64 para imagens

Envie qualquer desafio incomum como imagem mais instruções em texto — comece agora com a CaptchaAI.