CAPTCHA de texto vs CAPTCHA de imagen: comparación de desarrolladores

Cuando automatizas un flujo y te topas con un CAPTCHA, lo primero que decide todo lo demás es de qué tipo es. Un CAPTCHA de texto —esas letras y números distorsionados que escribes en un campo— se resuelve con OCR y cuesta muy poco. Un CAPTCHA de imagen —las cuadrículas de "selecciona los semáforos"— exige clasificación visual y es más lento y caro de automatizar. Esta comparación va al grano: en qué se diferencian en seguridad, accesibilidad, costo e integración, cómo detectar cuál tienes delante y cómo resolver cada uno con la API de CaptchaAI.

Texto vs imagen: comparación rápida

Esta tabla resume las diferencias que importan al integrar cada tipo en tu pipeline.

Si tuvieras que quedarte con tres ideas de esa tabla, serían estas:

• El de texto es barato pero débil: cuesta poco desplegarlo y resolverlo, y hoy apenas frena a un bot con OCR.
• El de imagen es caro pero resistente: exige clasificación visual, lo que sube la fricción y el costo de automatizarlo.
• A veces la respuesta es ninguno: si un reto invisible como Cloudflare Turnstile encaja con tu tráfico, evitas la fricción por completo.

Cómo funciona un CAPTCHA de texto

Un CAPTCHA de texto renderiza caracteres distorsionados como una imagen que el usuario lee y escribe en un campo. Su seguridad depende de que la distorsión sea legible para una persona pero difícil para un lector automático, y para eso combina varias técnicas: deforma los caracteres, añade ruido de fondo, solapa letras contiguas para impedir la segmentación y aleatoriza fuentes, tamaños y colores. El flujo, del servidor al campo, es este:

Server generates random string (e.g., "X7mK9p")
    ↓
Applies distortion: warping, noise, overlap
    ↓
Renders as PNG/JPEG image
    ↓
User reads characters, types into input field
    ↓
Server compares input against stored string (case-insensitive usually)

Cómo funciona un CAPTCHA de imagen

Un CAPTCHA de imagen presenta una cuadrícula de fotografías y pide seleccionar las que coinciden con una categoría. El reto ya no es leer texto sino percepción visual, y por eso cuesta mucho más automatizarlo. Según el proveedor, cambia de forma:

• Selección de cuadrícula (reCAPTCHA v2): "selecciona las casillas con semáforos".
• Etiquetado de imágenes (hCaptcha): "haz clic en las imágenes con un autobús".
• Conteo de objetos (personalizado): "¿cuántas bicicletas hay?".
• Rotación (FunCaptcha): "gira la imagen a la orientación correcta".

El flujo típico añade una fase ausente en el de texto —las imágenes que se recargan tras cada acierto—, y esa multironda dispara el costo de automatización:

Server selects images from a labeled dataset
    ↓
Presents 3×3 or 4×4 grid with a text prompt
    ↓
User clicks matching images
    ↓
Server validates selections against ground truth
    ↓
If fading images: new images load in place of selected ones (multi-round)

Cómo detectar qué tipo de CAPTCHA usa una página

Antes de integrar conviene saber qué sirve la página. Estas son las señales que delatan cada tipo en el marcado:

• google.com/recaptcha o la clase g-recaptcha apuntan a reCAPTCHA (imagen).
• hcaptcha.com o h-captcha apuntan a hCaptcha (imagen).
• Una <img> con "captcha" en la URL junto a un <input> de texto delata un CAPTCHA de texto propio.

Los ejemplos siguientes automatizan la comprobación y devuelven el proveedor probable para enrutar al solver correcto.

Detección con Python

import requests
from bs4 import BeautifulSoup
import re

def detect_captcha_type(url):
    """Detect whether page uses text or image CAPTCHA."""
    response = requests.get(url, timeout=10)
    soup = BeautifulSoup(response.text, "html.parser")
    html = response.text

    result = {"text_captcha": False, "image_captcha": False, "provider": None}

    # Check for reCAPTCHA (image-based)
    if "google.com/recaptcha" in html or "g-recaptcha" in html:
        result["image_captcha"] = True
        result["provider"] = "reCAPTCHA"
        return result

    # Check for hCaptcha (image-based)
    if "hcaptcha.com" in html or "h-captcha" in html:
        result["image_captcha"] = True
        result["provider"] = "hCaptcha"
        return result

    # Check for text CAPTCHA patterns
    captcha_images = soup.find_all("img", attrs={
        "src": re.compile(r"captcha", re.I)
    })
    captcha_inputs = soup.find_all("input", attrs={
        "name": re.compile(r"captcha", re.I)
    })

    if captcha_images and captcha_inputs:
        # Image with text input = text CAPTCHA
        result["text_captcha"] = True
        result["provider"] = "custom text CAPTCHA"
        return result

    # Check for FunCaptcha (image-based rotation)
    if "funcaptcha" in html.lower() or "arkoselabs" in html.lower():
        result["image_captcha"] = True
        result["provider"] = "FunCaptcha"
        return result

    return result

captcha = detect_captcha_type("https://staging.example.com/qa-login")
print(captcha)

Detección con Node.js

const axios = require("axios");
const cheerio = require("cheerio");

async function detectCaptchaType(url) {
    const { data: html } = await axios.get(url, { timeout: 10000 });
    const $ = cheerio.load(html);

    const result = { textCaptcha: false, imageCaptcha: false, provider: null };

    // reCAPTCHA detection
    if (html.includes("google.com/recaptcha") || html.includes("g-recaptcha")) {
        result.imageCaptcha = true;
        result.provider = "reCAPTCHA";
        return result;
    }

    // hCaptcha detection
    if (html.includes("hcaptcha.com") || html.includes("h-captcha")) {
        result.imageCaptcha = true;
        result.provider = "hCaptcha";
        return result;
    }

    // Text CAPTCHA: image + input with "captcha" in name/class
    const captchaImgs = $("img[src*='captcha' i]").length;
    const captchaInputs = $("input[name*='captcha' i]").length;

    if (captchaImgs > 0 && captchaInputs > 0) {
        result.textCaptcha = true;
        result.provider = "custom text CAPTCHA";
        return result;
    }

    return result;
}

detectCaptchaType("https://staging.example.com/qa-login").then(console.log);

Cómo resolver CAPTCHA de texto con la API de CaptchaAI

Un CAPTCHA de texto es, en el fondo, una imagen: el texto distorsionado se sirve como PNG o JPEG. Por eso la API de Image OCR de CaptchaAI lo procesa directamente, sin un solver por proveedor.

import requests
import base64
import time

API_KEY = "YOUR_API_KEY"

# Get the CAPTCHA image
captcha_url = "https://example.com/captcha.png"
image_data = requests.get(captcha_url).content
b64 = base64.b64encode(image_data).decode()

# Submit to CaptchaAI
submit = requests.post("https://ocr.captchaai.com/in.php", data={
    "key": API_KEY,
    "method": "base64",
    "body": b64,
    "json": 1,
})
task_id = submit.json()["request"]

# Poll for result
for _ in range(30):
    time.sleep(3)
    resp = requests.get("https://ocr.captchaai.com/res.php", params={
        "key": API_KEY,
        "action": "get",
        "id": task_id,
        "json": 1,
    }).json()

    if resp.get("status") == 1:
        print(f"CAPTCHA text: {resp['request']}")
        break

La misma API de Image OCR cubre una amplia variedad de retos basados en imagen —texto distorsionado, ecuaciones matemáticas y reconocimiento de caracteres— con un único endpoint. En resumen, esto puedes enrutar a CaptchaAI y esto no:

• Texto distorsionado y OCR: sí, con el endpoint de Image OCR de arriba.
• reCAPTCHA v2/v3, Cloudflare Turnstile e imagen en cuadrícula: sí, con solvers dedicados.
• hCaptcha y FunCaptcha: no compatibles por ahora; no los incluyas.

Qué tipo de CAPTCHA elegir según tu caso

Si eres tú quien decide cómo proteger un formulario, la elección depende de cuánta fricción toleras y de qué tan agresivo es el tráfico que recibes. Esta tabla te lleva de la situación a la recomendación:

Preguntas frecuentes

¿Cómo detecto qué tipo de CAPTCHA usa un sitio antes de integrar?

Inspecciona el marcado: g-recaptcha indica reCAPTCHA (imagen), h-captcha indica hCaptcha, y una <img> con "captcha" junto a un <input> de texto apunta a un CAPTCHA de texto propio. Los ejemplos de arriba automatizan esa comprobación.

¿Qué reto de imagen es el más difícil de automatizar?

Depende del proveedor, pero en general las cuadrículas que se recargan (multironda) y los retos de rotación son los más costosos, porque combinan clasificación visual con varias iteraciones. La cuadrícula estática de reCAPTCHA v2 es más manejable que un reto que recarga imágenes cada vez que aciertas.

¿Puede CaptchaAI resolver tanto CAPTCHA de texto como de imagen?

Sí. Resuelve los de texto con su API de Image OCR y los de imagen con sus solvers de reCAPTCHA v2/v3 e imagen en cuadrícula. hCaptcha y FunCaptcha no son compatibles por ahora, así que no cuentes con ellos en tu integración.

¿Siguen siendo útiles los CAPTCHA de texto en 2026?

Cada vez menos. Los motores de OCR modernos resuelven los CAPTCHA de texto estándar con más del 95% de precisión. Distorsionarlos mucho baja esa cifra al 80–85%, pero también los vuelve ilegibles: hoy un CAPTCHA de texto frena a más usuarios legítimos que a bots, y la tendencia es migrar a retos invisibles.

En resumen

Los CAPTCHA de texto son simples, baratos de desplegar y fáciles de resolver con OCR; los de imagen protegen mejor a cambio de más fricción y de un solver más complejo. Para quien automatiza, el texto solo necesita OCR —lo cubre la API de Image OCR de CaptchaAI—, mientras que la imagen exige solvers como los de reCAPTCHA e imagen en cuadrícula. Sobre el costo, CaptchaAI no cobra por resolución: sus planes son por thread (BASIC $15/mes con 5 threads) con resoluciones ilimitadas, así que el costo por cada 1000 baja con el volumen. Y en 2026 la dirección es clara: los CAPTCHA invisibles que eliminan la fricción.

Artículos relacionados

• CaptchaAI frente a CapMonster Cloud
• GeeTest frente a Cloudflare Turnstile
• Error 403 de Cloudflare Turnstile tras renovar el token