# YesCaptcha Docs (full text)
> YesCaptcha es una API de reconocimiento de captchas. Con una sola interfaz JSON resuelve reCAPTCHA, hCaptcha, Cloudflare Turnstile, FunCaptcha, AWS WAF y captchas de imagen, cobra por tarea y reembolsa los puntos automáticamente si el reconocimiento falla o se agota el tiempo.
---
# Resuelve captchas con una sola interfaz JSON
> YesCaptcha es una API de reconocimiento de captchas. Con una sola interfaz JSON resuelve reCAPTCHA, hCaptcha, Cloudflare Turnstile, FunCaptcha, AWS WAF y captchas de imagen, cobra por tarea y reembolsa los puntos automáticamente si el reconocimiento falla o se agota el tiempo.
Source: https://docs.yescaptcha.com/es/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/
[API de reconocimiento de captchasEstado](https://status.yescaptcha.com/?lang=en)
Resuelve reCAPTCHA, hCaptcha, Cloudflare Turnstile, FunCaptcha, AWS WAF y captchas de imagen alfanuméricos. Se cobra por tarea en puntos, 1,000 puntos = ¥1; si el reconocimiento falla o se agota el tiempo, los puntos se reembolsan automáticamente.
[Inicio rápido](https://docs.yescaptcha.com/es/getting-started/quickstart.md)[Referencia de la API](https://docs.yescaptcha.com/es/api/overview.md)
Versiones para IA y programas:[llms.txt](https://docs.yescaptcha.com/es/llms.txt)[llms-full.txt](https://docs.yescaptcha.com/es/llms-full.txt)[OpenAPI](https://docs.yescaptcha.com/openapi.json)[Markdown](https://docs.yescaptcha.com/es/index.md)
YesCaptcha solo puede usarse con fines legales. Queda prohibido cualquier uso ilegal.
POSTapi.yescaptcha.com/createTask
```
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "NoCaptchaTaskProxyless",
"websiteURL": "https://www.google.com/recaptcha/api2/demo",
"websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"
}
}
```
1. /createTasktaskId 61138bb6-19fb-11ec-a9c8-0242ac110006
2. /getTaskResultprocessing
3. /getTaskResultprocessing
4. /getTaskResultready
5. gRecaptchaResponse03AGdBq25SxXT-pmSeBXjzScW-EiocHwwpwqtk1QXlJnGnU...
1. 1Crear tarea
2. 2Obtener resultado
3. 3Enviar
Ejemplo: reCAPTCHA v2, consultando el resultado cada 5 segundos
Desde $0.30 / 1k
Precio más bajo por tarea
1,000 puntos = ¥1
Las tareas fallidas o con tiempo agotado tienen reembolso de puntos
2 endpoints
Endpoint global y endpoint China
9:00–21:00
Soporte humano (UTC+8)
[Inicio rápidoCrea tu cuenta, obtén tu ClientKey y envía tu primera solicitud en 5 minutos](https://docs.yescaptcha.com/es/getting-started/quickstart.md)[Referencia de la APIcreateTask, getTaskResult, códigos de error y límite de tareas simultáneas](https://docs.yescaptcha.com/es/api/overview.md)[Tipos de tarea y preciosPrecios, forma de respuesta y parámetros de todos los tipos públicos](https://docs.yescaptcha.com/es/tasks.md)[Extensión del navegadorCompleta verificaciones en las páginas web sin escribir código](https://docs.yescaptcha.com/es/extension.md)
## Captchas compatibles
[01reCAPTCHAv2, v3, Enterprise y reconocimiento de imágenes de v2Desde $0.90 / 1k](https://docs.yescaptcha.com/es/tasks/recaptcha-v2.md)[02hCaptchaDevuelve un token, o reconoce las imágenes y haz clic tú mismoDesde $1.20 / 1k](https://docs.yescaptcha.com/es/tasks/hcaptcha.md)[03Cloudflare TurnstileTokens de verificación de TurnstileDesde $3.75 / 1k](https://docs.yescaptcha.com/es/tasks/turnstile.md)[04FunCaptchaReconocimiento de los captchas de imágenes de Arkose Labs, compatible con todos los tipos de preguntaDesde $0.45 / 1k](https://docs.yescaptcha.com/es/tasks/funcaptcha-classification.md)[05AWS WAF / bCaptchaReconocimiento de imágenes en cuadrícula 3×3Desde $1.20 / 1k](https://docs.yescaptcha.com/es/tasks/aws-bcaptcha-classification.md)[06Imagen a textoCaptchas de caracteres alfanuméricos, respuesta síncronaDesde $0.30 / 1k](https://docs.yescaptcha.com/es/tasks/image-to-text.md)
## Integración en tres pasos
1. 01
**Crea una tarea**
Envía el tipo de tarea y los parámetros del sitio con `createTask` y obtendrás un `taskId`. Los tipos síncronos, como el reconocimiento de imágenes y imagen a texto, devuelven el resultado directamente.
2. 02
**Obtén el resultado**
Llama a `getTaskResult` cada 5 segundos. Cuando `status` pasa a `ready`, el resultado está en `solution`.
3. 03
**Envíalo al sitio de destino**
Coloca el token en el formulario o la solicitud de la página. El token es de un solo uso; se recomienda usarlo en un máximo de 60 segundos.
POST /createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "NoCaptchaTaskProxyless",
"websiteURL": "https://www.google.com/recaptcha/api2/demo",
"websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"
}
}
```
POST /getTaskResult
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"gRecaptchaResponse": "03AGdBq25SxXT-pmSeBXjzScW-EiocHwwpwqtk1QXlJnGnU..."
}
}
```
## Accesos frecuentes
- [**Códigos de error**Qué significa cada código de error y cómo resolverlo](https://docs.yescaptcha.com/es/api/errors.md)
- [**Límite de tareas simultáneas y pausa automática**Qué ocurre al superar el límite o con demasiados errores](https://docs.yescaptcha.com/es/api/rate-limits.md)
- [**Facturación y reembolsos**Puntos, cobro previo, reembolso de puntos y reembolso tras reportar](https://docs.yescaptcha.com/es/getting-started/billing.md)
- [**Contáctanos**WeChat, QQ, Telegram y correo, horario de atención 9:00–21:00 (UTC+8)](https://docs.yescaptcha.com/es/help/contact.md)
- [**Panel**Crea tu cuenta, obtén tu ClientKey y recarga](https://yescaptcha.com/)
---
# Introducción
> Qué es YesCaptcha. Resuelve reCAPTCHA, hCaptcha, Turnstile, FunCaptcha y captchas de imagen mediante una API o una extensión del navegador, con cobro por tarea y reembolso automático de puntos en las tareas fallidas.
Source: https://docs.yescaptcha.com/es/getting-started/introduction/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/getting-started/introduction/
YesCaptcha es un servicio de reconocimiento de captchas. Envías los datos del captcha a la API de YesCaptcha y recibes un token que puedes enviar directamente al sitio de destino, o el resultado del reconocimiento de una imagen. Es compatible con reCAPTCHA (v2, v3 y Enterprise), hCaptcha, Cloudflare Turnstile, la página de verificación de Cloudflare, FunCaptcha, AWS WAF, bCaptcha y captchas de imagen alfanuméricos. Se cobra por tarea en puntos (1,000 puntos = ¥1); las tareas fallidas o que superan el tiempo de espera reciben un reembolso de puntos automático.
YesCaptcha solo puede usarse con fines legales. Cualquier uso ilegal está prohibido.
## Dos formas de usarlo
| | API | Extensión del navegador (YesCaptcha Assistant) |
| --- | --- | --- |
| Ideal para | Desarrolladores que procesan captchas por lotes desde su propio código | Quienes no escriben código y trabajan en el navegador |
| Cómo se usa | Llama a `createTask` y `getTaskResult` con tu `clientKey` | Instala la extensión e introduce tu `clientKey`; los captchas se reconocen y se pulsan automáticamente |
| Compatibilidad | Todos los tipos de tarea que aparecen en este sitio | Desafíos de imágenes y captchas de caracteres de reCAPTCHA v2, hCaptcha, FunCaptcha, AWS WAF y bCaptcha |
| Costo | Puntos según el tipo de tarea | La extensión es gratuita; se cobran los puntos de las llamadas a la API que realiza |
Ambas formas usan la misma cuenta, el mismo `clientKey` y el mismo saldo.
## Tres tipos de resultado
- **token**: la mayoría de los tipos de tarea de reCAPTCHA, hCaptcha, Turnstile y FunCaptcha. Devuelven una cadena que se coloca en el formulario o la solicitud de la página para superar la verificación, sin necesidad de pulsar imágenes. Todos son asíncronos: crea la tarea y consulta el resultado cada 5 segundos.
- **Resultado de reconocimiento de imágenes**: los tipos cuyo nombre termina en `Classification`. Envías las imágenes del captcha y recibes qué imágenes o qué posición hay que pulsar; tu programa realiza el clic en el navegador. Son síncronos: una sola solicitud devuelve el resultado.
- **Texto o cookies**: el reconocimiento de captchas de imagen alfanuméricos devuelve el texto de la imagen; la página de verificación de Cloudflare devuelve las cookies obtenidas tras superar la verificación.
Todos los tipos y precios: [Tipos de tarea y precios](https://docs.yescaptcha.com/es/tasks.md).
## Empieza aquí
[Inicio rápido](https://docs.yescaptcha.com/es/getting-started/quickstart.md)Crea tu cuenta, obtén tu clientKey y envía tu primera solicitud
[Endpoints](https://docs.yescaptcha.com/es/getting-started/endpoints.md)Endpoint global y endpoint China
[Cobros y reembolsos](https://docs.yescaptcha.com/es/getting-started/billing.md)Puntos, cobro previo, reembolso de puntos y reembolso tras reportar
[Extensión del navegador](https://docs.yescaptcha.com/es/extension.md)Reconoce captchas en el navegador sin escribir código
## SDK de la comunidad
SDK aportados por usuarios (no oficiales; evalúalos antes de usarlos): consulta [Código de ejemplo y SDK](https://docs.yescaptcha.com/es/samples.md).
---
# Inicio rápido
> Envía tu primera solicitud a YesCaptcha en 5 minutos: crea tu cuenta, copia tu ClientKey, recarga saldo y reconoce un captcha de imagen con curl, Python o Node.js (ImageToTextTaskOcrBase, síncrono, 2 puntos por solicitud).
Source: https://docs.yescaptcha.com/es/getting-started/quickstart/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/getting-started/quickstart/
Esta página envía una primera solicitud con el tipo de tarea más sencillo, `ImageToTextTaskOcrBase`, que reconoce las letras y los números de una imagen. Es síncrono: una sola solicitud `createTask` devuelve el resultado. Cuesta 2 puntos (≈ $0.30 / 1k) por solicitud y no depende de sitios de terceros, así que sirve para comprobar que tu cuenta y tu código funcionan.
1. **Crea tu cuenta**
Abre [yescaptcha.com](https://yescaptcha.com/), crea tu cuenta e inicia sesión.
2. **Copia tu ClientKey**
Una vez dentro, en el Panel ([yescaptcha.com/dashboard.html](https://yescaptcha.com/dashboard.html)) busca “Tu ClientKey” y haz clic en copiar. Copia el valor completo.
> **Precaución:** Todas las solicitudes a la API se autentican con el ClientKey, así que quien lo tenga puede gastar tu saldo. No lo compartas ni lo escribas en código público; si se filtra, puedes restablecerlo en el mismo lugar.
3. **Recarga saldo**
El saldo debe ser superior a 10 puntos para poder crear tareas. Los métodos de pago y el bono VIP están en [Recarga y VIP](https://docs.yescaptcha.com/es/account/recharge.md).
4. **Comprueba que el ClientKey funciona**
`getBalance` consulta el saldo y no cobra puntos:
```bash
curl -s https://api.yescaptcha.com/getBalance \
-H 'Content-Type: application/json' \
-d '{"clientKey": "YOUR_CLIENT_KEY"}'
```
Si recibes `{"errorId": 0, "balance": 12345, ...}`, todo está listo; `balance` son los puntos restantes. Si recibes `ERROR_KEY_DOES_NOT_EXIST`, la clave se copió mal.
5. **Reconoce una imagen**
Descarga la imagen de ejemplo [captcha.jpg](https://docs.yescaptcha.com/samples/captcha.jpg) (también puedes usar tu propia imagen de captcha), guarda tu ClientKey en una variable de entorno y ejecuta uno de los scripts:
```bash
export YESCAPTCHA_CLIENT_KEY=your_client_key
```
**curl**
quickstart.sh
```bash
#!/usr/bin/env bash
# First request: read an alphanumeric image captcha with ImageToTextTaskOcrBase (synchronous, 2 points per image)
# Usage: YESCAPTCHA_CLIENT_KEY=your_client_key bash quickstart.sh captcha.png
set -euo pipefail
IMAGE="${1:-captcha.png}"
BODY=$(base64 < "$IMAGE" | tr -d '\n') # no "data:" prefix, no line breaks
curl -s https://api.yescaptcha.com/createTask \
-H 'Content-Type: application/json' \
-d "{\"clientKey\": \"${YESCAPTCHA_CLIENT_KEY}\", \"task\": {\"type\": \"ImageToTextTaskOcrBase\", \"body\": \"${BODY}\"}}"
echo
```
**Python**
quickstart.py
```python
"""First request: read an alphanumeric image captcha with ImageToTextTaskOcrBase
(synchronous, 2 points per image).
Usage:
export YESCAPTCHA_CLIENT_KEY=your_client_key
python quickstart.py captcha.png
"""
import base64
import os
import sys
import requests
CLIENT_KEY = os.environ["YESCAPTCHA_CLIENT_KEY"]
image_path = sys.argv[1] if len(sys.argv) > 1 else "captcha.png"
with open(image_path, "rb") as f:
body = base64.b64encode(f.read()).decode() # no "data:" prefix
r = requests.post(
"https://api.yescaptcha.com/createTask",
json={
"clientKey": CLIENT_KEY,
"task": {"type": "ImageToTextTaskOcrBase", "body": body},
},
timeout=30,
)
data = r.json()
if data.get("errorId"):
raise SystemExit(f"{data.get('errorCode')}: {data.get('errorDescription')}")
print("text:", data["solution"]["text"])
```
**Node.js**
quickstart.mjs
```js
// First request: read an alphanumeric image captcha with ImageToTextTaskOcrBase (synchronous, 2 points per image).
// Usage: YESCAPTCHA_CLIENT_KEY=your_client_key node quickstart.mjs captcha.png
import { readFileSync } from 'node:fs';
const CLIENT_KEY = process.env.YESCAPTCHA_CLIENT_KEY;
const body = readFileSync(process.argv[2] ?? 'captcha.png').toString('base64'); // no "data:" prefix
const res = await fetch('https://api.yescaptcha.com/createTask', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ clientKey: CLIENT_KEY, task: { type: 'ImageToTextTaskOcrBase', body } }),
});
const data = await res.json();
if (data.errorId) throw new Error(`${data.errorCode}: ${data.errorDescription}`);
console.log('text:', data.solution.text);
```
Ejecuta `bash quickstart.sh captcha.jpg`, `python quickstart.py captcha.jpg` o `node quickstart.mjs captcha.jpg`. Python requiere `pip install requests` antes; Node.js requiere la versión 18 o superior.
6. **Consulta el resultado**
Si todo va bien, recibes:
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"text": "LMResm"
},
"taskId": "2376919c-1863-11ec-a012-94e6f7355a0b"
}
```
`errorId` igual a 0 indica éxito, y el texto reconocido está en `solution.text`. Si `errorId` es 1, revisa `errorCode`; su significado está en [Códigos de error](https://docs.yescaptcha.com/es/api/errors.md).
## Siguientes pasos
- Las tareas que devuelven token, como reCAPTCHA y hCaptcha, son **asíncronas**: `createTask` devuelve primero un `taskId` y después consultas `getTaskResult` cada 5 segundos. El flujo completo está en [Solicitudes y respuestas](https://docs.yescaptcha.com/es/api/overview.md); un ejemplo es [reCAPTCHA v2](https://docs.yescaptcha.com/es/tasks/recaptcha-v2.md).
- Elige un tipo de tarea: [Tipos de tarea y precios](https://docs.yescaptcha.com/es/tasks.md).
- Un cliente que puedes copiar directamente a tu proyecto: [Python](https://docs.yescaptcha.com/es/samples/python.md), [Node.js](https://docs.yescaptcha.com/es/samples/nodejs.md).
- Sin escribir código: [extensión del navegador](https://docs.yescaptcha.com/es/extension.md).
---
# Endpoints
> Los dos endpoints de la API de YesCaptcha: el global api.yescaptcha.com y el de China cn.yescaptcha.com. Solo HTTPS POST con JSON; crea y consulta una tarea en el mismo endpoint.
Source: https://docs.yescaptcha.com/es/getting-started/endpoints/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/getting-started/endpoints/
La API de YesCaptcha tiene dos endpoints con los mismos métodos y parámetros. Elige el más cercano a tus servidores:
| Endpoint | Dirección | Úsalo para |
| --- | --- | --- |
| Global | `https://api.yescaptcha.com` | Servidores fuera de China continental |
| China | `https://cn.yescaptcha.com` | Servidores en China continental |
La URL de un método es el endpoint más el nombre del método, por ejemplo para crear una tarea:
- POST `https://api.yescaptcha.com/createTask` (Endpoint global)
- POST `https://cn.yescaptcha.com/createTask` (Endpoint China)
## Reglas
- Usa solo HTTPS.
- Todos los métodos excepto [/useragent](https://docs.yescaptcha.com/es/api/useragent.md) usan `POST` con un cuerpo JSON y el encabezado `Content-Type: application/json`. El cuerpo no puede superar los 6 MB.
- La autenticación se hace con el `clientKey` del cuerpo; no se necesitan otros encabezados.
> **Nota:** Consulta una tarea con `getTaskResult` en el mismo endpoint en el que la creaste. No mezcles los dos endpoints.
## Todos los métodos
| Método | Función | Notas |
| --- | --- | --- |
| [createTask](https://docs.yescaptcha.com/es/api/create-task.md) | Crear una tarea | Los tipos síncronos devuelven el resultado directamente |
| [getTaskResult](https://docs.yescaptcha.com/es/api/get-task-result.md) | Obtener el resultado de la tarea | En los tipos asíncronos, consulta cada 5 segundos |
| [getBalance](https://docs.yescaptcha.com/es/api/get-balance.md) | Consultar el saldo | No cobra puntos |
| [getSoftID](https://docs.yescaptcha.com/es/api/get-soft-id.md) | Consultar tu ID de desarrollador | Para la participación del desarrollador |
| [report](https://docs.yescaptcha.com/es/api/report.md) | Reportar resultados | En los tipos de reconocimiento de imágenes se puede solicitar un reembolso tras reportar |
| [useragent](https://docs.yescaptcha.com/es/api/useragent.md) | Obtener el User-Agent recomendado | `GET`, se usa con hCaptcha |
Si no puedes conectarte, consulta [Problemas de conexión y red](https://docs.yescaptcha.com/es/help/troubleshooting.md).
---
# Facturación y reembolsos
> Cómo cobra YesCaptcha: 1,000 puntos = ¥1, según el tipo de tarea; las tareas fallidas o con tiempo agotado se reembolsan automáticamente, las solicitudes que devuelven error no se cobran; el saldo debe ser mayor a 10 puntos; los reportes de fallo de reconocimiento de imágenes se reembolsan tras unas 24 horas.
Source: https://docs.yescaptcha.com/es/getting-started/billing/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/getting-started/billing/
YesCaptcha cobra por tarea: cada tipo de tarea tiene un precio fijo, 1,000 puntos = ¥1. Por ejemplo, `NoCaptchaTaskProxyless` cuesta 15 puntos (≈ $2.25 / 1k) por tarea. Los precios de cada tipo están en [Tipos de tarea y precios](https://docs.yescaptcha.com/es/tasks.md).
> **Consejo:** Solo pagas las tareas exitosas: las tareas fallidas o con tiempo agotado se reembolsan automáticamente, y las solicitudes que devuelven error no se cobran.
## Cuándo se cobran los puntos
- **Tipos asíncronos** (la mayoría de los tipos que devuelven token): el cobro de puntos se hace al crear la tarea. Si después falla (`ERROR_CAPTCHA_UNSOLVABLE` y similares) o se agota el tiempo (`ERROR_TASK_TIMEOUT`, normalmente 110 segundos), los puntos se reembolsan automáticamente.
- **Tipos síncronos** (reconocimiento de imágenes, `ImageToTextTaskOcrBase`, `ImageToTextTaskMuggle`): el cobro se hace cuando se devuelve el resultado.
- Las solicitudes que devuelven error al crear la tarea (parámetros incorrectos, saldo insuficiente, límite de tareas simultáneas superado, etc.) no se cobran.
## Saldo
- El saldo debe ser **mayor a 10 puntos** para crear tareas; de lo contrario se devuelve `ERROR_ZERO_BALANCE`.
- Consulta el saldo con [getBalance](https://docs.yescaptcha.com/es/api/get-balance.md); no tiene costo.
- Para la recarga y el bono VIP, consulta [Recarga y VIP](https://docs.yescaptcha.com/es/account/recharge.md): cuando tu recarga acumulada alcanza un Nivel VIP, cada recarga posterior recibe puntos de bono en proporción.
## Tipos con precio según el caso
- **Reconocimiento de imágenes de reCAPTCHA v2** (`ReCaptchaV2Classification`): las imágenes pequeñas 1x1 y las grandes 3x3 y 4x4 tienen precios distintos; consulta [Reconocimiento de imágenes de reCAPTCHA v2](https://docs.yescaptcha.com/es/tasks/recaptcha-classification.md).
- **Reconocimiento de imágenes de hCaptcha** (`HCaptchaClassification`): no se cobra cuando no se identifica ningún objetivo (resultado vacío).
## Reembolso tras reportar un error de reconocimiento
Si el resultado de un reconocimiento de imágenes fue incorrecto, puedes reportarlo con [report](https://docs.yescaptcha.com/es/api/report.md); los casos que cumplen las condiciones reciben reembolso de puntos:
- Solo aplica a 5 tipos de reconocimiento de imágenes: `FunCaptchaClassification`, `HCaptchaClassification`, `ReCaptchaV2Classification`, `AwsClassification` y `bCaptchaClassification`.
- Reporta **dentro de 1 hora** después de crear la tarea; cada tarea se cuenta una sola vez.
- El reembolso no es inmediato: se liquida en conjunto **unas 24 horas después**.
- En la liquidación se compara con otros usuarios del mismo periodo y la misma pregunta: si la tasa de fallos que reportas es claramente superior a la del periodo, el reembolso se calcula con la tasa de fallos del periodo.
- Reporta tanto los éxitos como los fallos con honestidad; los reportes que solo marcan fallos no se usan como referencia del periodo, y la tasa de fallos se calcula sobre todas las tareas que creaste.
- Si tienes dudas sobre el resultado de la liquidación, puedes [contactar a Soporte](https://docs.yescaptcha.com/es/help/contact.md) para apelar.
En los tipos que devuelven token (reCAPTCHA, hCaptcha, Turnstile, etc.), el sitio de destino decide si el token es válido, por lo que reportar no genera reembolso.
## Casos en que no se cobra
| Situación | Respuesta |
| --- | --- |
| Parámetros incorrectos, tipo inexistente, `clientKey` incorrecto | El código de error correspondiente |
| Saldo no mayor a 10 puntos | `ERROR_ZERO_BALANCE` |
| Se superó el límite de tareas simultáneas | `ERROR_THREADS_MAXIMUM`; consulta [Límite de tareas simultáneas y pausa automática](https://docs.yescaptcha.com/es/api/rate-limits.md) |
| Durante una pausa automática | `ERROR_IP_BLOCKED_5MIN` |
| sitekey o dominio ya identificado como no válido (dentro del periodo de caché) | El código de error original, con `cached: true` |
| Fallo de reconocimiento o tiempo agotado | Los puntos ya cobrados se reembolsan automáticamente |
## Participación y recompensas
- Si usas el software o la extensión de otra persona, las tareas pueden llevar un ID de desarrollador; el desarrollador recibe una participación y tu cobro no cambia. Si desarrollas tu propio software, consulta [Participación del desarrollador](https://docs.yescaptcha.com/es/account/developer.md).
- Para invitar a otras personas a crear una cuenta, consulta [Recompensa por referidos](https://docs.yescaptcha.com/es/account/referral.md).
---
# Solicitudes y respuestas
> Convenciones comunes de la API de YesCaptcha. POST con JSON, autenticación con ClientKey, formato de respuesta con errorId, tareas síncronas y asíncronas, consulta periódica (polling) cada 5 segundos, timeout de 110 segundos, resultados guardados unos 10 minutos e idioma de los mensajes según Accept-Language.
Source: https://docs.yescaptcha.com/es/api/overview/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/api/overview/
Todos los métodos usan HTTPS `POST` con un cuerpo JSON (solo `/useragent` es `GET`), se autentican con el `clientKey` del cuerpo y devuelven JSON: `errorId` 0 significa éxito y 1 significa fallo, con un `errorCode`. Resolver un captcha tiene dos pasos: `createTask` crea la tarea y `getTaskResult` se consulta cada 5 segundos para obtener el resultado. Los tipos síncronos devuelven el resultado directamente en `createTask`.
## Solicitud
```bash
curl -s https://api.yescaptcha.com/createTask \
-H 'Content-Type: application/json' \
-d '{"clientKey": "YOUR_CLIENT_KEY", "task": {"type": "ImageToTextTaskOcrBase", "body": "BASE64_IMAGE"}}'
```
- Endpoint: `https://api.yescaptcha.com` (global) o `https://cn.yescaptcha.com` (China). Consulta [Direcciones de acceso](https://docs.yescaptcha.com/es/getting-started/endpoints.md).
- El cuerpo es JSON, se envía con el encabezado `Content-Type: application/json` y no puede superar 6 MB. El JSON no admite comentarios.
- Cada solicitud debe incluir `clientKey`, copiado completo desde el Panel.
> **Precaución:** Con requests de Python usa `json=data`, no `data=data`. Esta última envía un formulario y devuelve `ERROR_TASK_ABSENT` o `ERROR_REQUIRED_FIELDS`.
## Respuesta
Éxito:
```json
{
"errorId": 0,
"taskId": "61138bb6-19fb-11ec-a9c8-0242ac110006"
}
```
Fallo:
```json
{
"errorId": 1,
"errorCode": "ERROR_ZERO_BALANCE",
"errorDescription": "帐户余额不足"
}
```
| Campo | Descripción |
| --- | --- |
| `errorId` | 0 éxito, 1 fallo |
| `errorCode` | Código de error en caso de fallo; su significado y cómo resolverlo están en [Códigos de error](https://docs.yescaptcha.com/es/api/errors.md) |
| `errorDescription` | Descripción en texto del motivo del fallo |
| `taskId` | ID de tarea |
| `status` | `processing` (en proceso) o `ready` (completada) |
| `solution` | Resultado del reconocimiento; sus campos dependen del tipo de tarea (consulta la página de cada tipo) |
Para evaluar el resultado, usa `errorId` y `errorCode`; no analices el texto de `errorDescription`, ya que puede cambiar.
## Síncrono y asíncrono
| | Asíncrono | Síncrono |
| --- | --- | --- |
| Qué tipos | Tipos que devuelven token (reCAPTCHA, hCaptcha, Turnstile, FunCaptcha), página de verificación de Cloudflare, `ImageToTextTask`, `ImageToTextTaskM1` | Reconocimiento de imágenes (nombres que terminan en `Classification`), `ImageToTextTaskOcrBase`, `ImageToTextTaskMuggle` |
| `createTask` devuelve | `taskId` | `status: "ready"` y `solution` |
| Cómo obtener el resultado | Llama a `getTaskResult` cada 5 segundos | No hace falta consultar de nuevo |
Para saber a qué grupo pertenece cada tipo, consulta la columna “Modo de respuesta” de [Tipos de tarea y precios](https://docs.yescaptcha.com/es/tasks.md).
## Consulta periódica (polling)
1. Cuando `createTask` devuelva un `taskId`, espera 5 segundos y llama a `getTaskResult`.
2. Si devuelve `status: "processing"`, espera otros 5 segundos y reintenta; si devuelve `status: "ready"`, el resultado está en `solution`.
3. Si devuelve `errorId: 1`, deja de consultar esa tarea y gestiona el `errorCode`.
- Las consultas repetidas del mismo `taskId` dentro de 5 segundos devuelven `processing` de inmediato; consultar con más frecuencia no da el resultado antes.
- Una tarea se procesa como máximo unos 110 segundos (180 a 220 segundos en algunos tipos); si se supera, devuelve `ERROR_TASK_TIMEOUT` y se hace el reembolso de puntos automáticamente.
- El resultado se guarda en el servidor unos 10 minutos; después el `taskId` caduca y la consulta devuelve `ERROR_TASKID_INVALID`.
- Consultar el resultado no cobra puntos; solo se cobran al crear la tarea.
## Idioma de los mensajes
En los avisos de pausa automática, caché de parámetros inválidos y fin de la consulta periódica, `errorDescription` se elige según el encabezado `Accept-Language`: si empieza por `zh` se devuelve en chino, con cualquier otro idioma se devuelve en inglés, y si no se envía el encabezado se devuelven ambos. Las descripciones de los demás códigos de error no cambian.
## Siguiente paso
- [createTask: crear una tarea](https://docs.yescaptcha.com/es/api/create-task.md)
- [getTaskResult: obtener el resultado](https://docs.yescaptcha.com/es/api/get-task-result.md)
- [Límite de tareas simultáneas y pausa automática](https://docs.yescaptcha.com/es/api/rate-limits.md): si hay demasiados errores, se pausa tu cuenta unos minutos
---
# createTask — crear una tarea
> POST /createTask crea una tarea de reconocimiento de captcha. Parámetros de la solicitud (clientKey, task, softID), orden de las comprobaciones, las tareas asíncronas devuelven taskId y las síncronas devuelven solution directamente; el saldo debe ser superior a 10 puntos.
Source: https://docs.yescaptcha.com/es/api/create-task/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/api/create-task/
`createTask` crea una tarea de reconocimiento; `task.type` indica qué captcha resolver. Los tipos asíncronos devuelven un `taskId`, que después usas con [getTaskResult](https://docs.yescaptcha.com/es/api/get-task-result.md) para obtener el resultado; los tipos síncronos devuelven el resultado directamente.
> **Nota:** El cobro de puntos se hace cuando la tarea se crea correctamente, y el saldo debe ser superior a 10 puntos para poder crear una tarea. Las tareas que fallan o expiran reciben un reembolso de puntos automático.
- POST `https://api.yescaptcha.com/createTask` (Endpoint global)
- POST `https://cn.yescaptcha.com/createTask` (Endpoint China)
## Parámetros de la solicitud
| Campo | Tipo | Obligatorio | Descripción |
| --- | --- | --- | --- |
| `clientKey` | string | Sí | Tu ClientKey, cópiala desde el Panel de [yescaptcha.com](https://yescaptcha.com/) |
| `task` | object | Sí | Objeto de la tarea. Debe incluir `type`; los demás campos dependen del tipo de tarea (consulta la página de cada tipo) |
| `softID` | integer | No | ID de desarrollador. Inclúyelo cuando otras personas usen el software que desarrollaste para recibir una participación del desarrollador; consulta [Participación del desarrollador](https://docs.yescaptcha.com/es/account/developer.md) |
## Ejemplos de solicitud
Reconocer un captcha de imagen (síncrono):
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "ImageToTextTaskOcrBase",
"body": "BASE64_IMAGE"
}
}
```
Obtener un token de reCAPTCHA v2 (asíncrono):
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "NoCaptchaTaskProxyless",
"websiteURL": "https://www.google.com/recaptcha/api2/demo",
"websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"
}
}
```
Los campos de `task` de cada tipo están en las páginas de [Tipos de tarea y precios](https://docs.yescaptcha.com/es/tasks.md).
## Respuesta
Tipos asíncronos:
```json
{
"errorId": 0,
"taskId": "61138bb6-19fb-11ec-a9c8-0242ac110006"
}
```
Guarda el `taskId` y empieza a consultar con `getTaskResult` 5 segundos después.
Tipos síncronos:
```json
{
"errorId": 0,
"status": "ready",
"taskId": "2376919c-1863-11ec-a012-94e6f7355a0b",
"solution": {
"text": "LMResm"
}
}
```
Fallo:
```json
{
"errorId": 1,
"errorCode": "ERROR_TASK_NOT_SUPPORTED",
"errorDescription": "任务类型不正确或不受支持"
}
```
## Orden de las comprobaciones
El servidor comprueba la solicitud en este orden y devuelve el código de error del primer problema que encuentra, sin cobro de puntos:
1. El cuerpo es un JSON válido: `ERROR_REQUEST_FORMATS`
2. Se incluyó `clientKey`: `ERROR_REQUIRED_FIELDS`
3. `clientKey` existe: `ERROR_KEY_DOES_NOT_EXIST`
4. No está en pausa automática: `ERROR_IP_BLOCKED_5MIN` (consulta [Límite de tareas simultáneas y pausa automática](https://docs.yescaptcha.com/es/api/rate-limits.md))
5. El saldo es superior a 10 puntos: `ERROR_ZERO_BALANCE`
6. Se incluyó `task`: `ERROR_TASK_ABSENT`
7. `task.type` existe: `ERROR_TASK_NOT_SUPPORTED`
8. Están todos los campos obligatorios: `ERROR_REQUIRED_FIELDS` (`errorDescription` indica qué campo falta)
9. En las tareas con imagen, la imagen es válida: `ERROR_ZERO_CAPTCHA_FILESIZE`, `ERROR_IMAGE_TYPE_NOT_SUPPORTED`, etc.
## Ejemplo completo
Crear una tarea y consultar el resultado periódicamente (tipo asíncrono):
**curl**
```bash
curl -s https://api.yescaptcha.com/createTask \
-H 'Content-Type: application/json' \
-d '{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "NoCaptchaTaskProxyless",
"websiteURL": "https://www.google.com/recaptcha/api2/demo",
"websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"
}
}'
# Returns {"errorId":0,"taskId":"..."}; then poll every 5 seconds:
curl -s https://api.yescaptcha.com/getTaskResult \
-H 'Content-Type: application/json' \
-d '{"clientKey": "YOUR_CLIENT_KEY", "taskId": "TASK_ID"}'
```
**Python**
solve.py
```python
import os
import time
import requests
API = "https://api.yescaptcha.com"
CLIENT_KEY = os.environ["YESCAPTCHA_CLIENT_KEY"] # Read the clientKey from an environment variable
def call(method, payload):
r = requests.post(f"{API}/{method}", json={"clientKey": CLIENT_KEY, **payload}, timeout=30)
data = r.json()
if data.get("errorId"):
raise RuntimeError(f"{data.get('errorCode')}: {data.get('errorDescription')}")
return data
def solve(task):
task_id = call("createTask", {"task": task})["taskId"]
for _ in range(36): # Poll every 5 seconds, for up to about 3 minutes
time.sleep(5)
result = call("getTaskResult", {"taskId": task_id})
if result.get("status") == "ready":
return result["solution"]
raise TimeoutError(task_id)
solution = solve({
"type": "NoCaptchaTaskProxyless",
"websiteURL": "https://www.google.com/recaptcha/api2/demo",
"websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
})
print(solution["gRecaptchaResponse"])
```
**Node.js**
solve.mjs
```js
const API = 'https://api.yescaptcha.com';
const CLIENT_KEY = process.env.YESCAPTCHA_CLIENT_KEY; // Read the clientKey from an environment variable
async function call(method, payload) {
const res = await fetch(`${API}/${method}`, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ clientKey: CLIENT_KEY, ...payload }),
});
const data = await res.json();
if (data.errorId) throw new Error(`${data.errorCode}: ${data.errorDescription}`);
return data;
}
async function solve(task) {
const { taskId } = await call('createTask', { task });
for (let i = 0; i < 36; i++) { // Poll every 5 seconds, for up to about 3 minutes
await new Promise((r) => setTimeout(r, 5000));
const result = await call('getTaskResult', { taskId });
if (result.status === 'ready') return result.solution;
}
throw new Error(`timeout: ${taskId}`);
}
const solution = await solve({
type: "NoCaptchaTaskProxyless",
websiteURL: "https://www.google.com/recaptcha/api2/demo",
websiteKey: "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
});
console.log(solution.gRecaptchaResponse);
```
---
# getTaskResult — obtener el resultado
> POST /getTaskResult consulta el resultado de una tarea asíncrona: consulta cada 5 segundos, sigue esperando con processing, lee solution con ready y detén la consulta periódica si hay un error; una tarea tarda hasta unos 110 segundos, el resultado se conserva unos 10 minutos y las consultas no cobran puntos.
Source: https://docs.yescaptcha.com/es/api/get-task-result/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/api/get-task-result/
`getTaskResult` consulta el resultado de una tarea asíncrona. Después de crear la tarea, llámalo cada 5 segundos: si devuelve `processing`, sigue esperando; si devuelve `ready`, el resultado está en `solution`; si devuelve un error, detente. Las consultas no cobran puntos, sin importar cuántas hagas.
- POST `https://api.yescaptcha.com/getTaskResult` (Endpoint global)
- POST `https://cn.yescaptcha.com/getTaskResult` (Endpoint China)
## Parámetros de la solicitud
| Campo | Tipo | Obligatorio | Descripción |
| --- | --- | --- | --- |
| `clientKey` | string | Sí | Tu ClientKey, el mismo que usaste al crear la tarea |
| `taskId` | string | Sí | El ID de tarea que devuelve [createTask](https://docs.yescaptcha.com/es/api/create-task.md) |
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"taskId": "61138bb6-19fb-11ec-a9c8-0242ac110006"
}
```
## Respuesta
| Situación | Respuesta | Qué hacer |
| --- | --- | --- |
| En proceso | `errorId` es 0, `status` es `processing` | Consulta de nuevo en 5 segundos |
| Completada | `errorId` es 0, `status` es `ready`, el resultado está en `solution` | Lee `solution`; sus campos están en la página de cada tipo de tarea |
| No se pudo resolver | `errorId` es 1, `errorCode` es `ERROR_CAPTCHA_UNSOLVABLE` | Ya se reembolsaron los puntos automáticamente; puedes crear una tarea nueva |
| Tiempo agotado | `errorId` es 1, `errorCode` es `ERROR_TASK_TIMEOUT` | Ya se reembolsaron los puntos automáticamente; puedes crear una tarea nueva |
| La tarea no existe o expiró | `errorId` es 1, `errorCode` es `ERROR_TASKID_INVALID` | Deja de consultar este `taskId` |
Ejemplo de tarea completada (reCAPTCHA v2):
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"gRecaptchaResponse": "03AGdBq25SxXT-pmSeBXjzScW-EiocHwwpwqtk1QXlJnGnU..."
}
}
```
## Reglas
- **Consulta cada 5 segundos.** Las consultas repetidas del mismo `taskId` dentro de 5 segundos devuelven `processing` de inmediato; consultar con más frecuencia no acelera el resultado.
- **Una tarea se procesa como máximo unos 110 segundos** (180 a 220 segundos en unos pocos tipos). Si se agota el tiempo, devuelve `ERROR_TASK_TIMEOUT` y se reembolsan los puntos automáticamente. Te recomendamos fijar en tu código un tiempo máximo de espera de unos 3 minutos.
- **El resultado se conserva unos 10 minutos**; después, el `taskId` deja de ser válido y devuelve `ERROR_TASKID_INVALID`. Usa el resultado cuanto antes: el token en sí caduca antes (unos 120 segundos en reCAPTCHA).
- **Si hay un error, detente.** Después de `errorId: 1`, seguir consultando el mismo `taskId` no cambia el resultado; a partir de la tercera consulta de una tarea ya finalizada, el final de `errorDescription` te indica que detengas la consulta periódica. `ERROR_TASKID_INVALID` cuenta como error para la [pausa automática](https://docs.yescaptcha.com/es/api/rate-limits.md) (con el mismo ID solo cuenta la primera vez).
- Consulta en el mismo endpoint en el que creaste la tarea.
- `getTaskResult` no se ve afectado por la pausa automática: las tareas creadas antes de la pausa se pueden consultar con normalidad.
---
# getBalance: consultar el saldo
> POST /getBalance consulta el saldo de la cuenta (puntos, 1,000 puntos = ¥1) y los saldos de participación del desarrollador y de recompensa por referidos. No cobra puntos y sirve para verificar tu clientKey.
Source: https://docs.yescaptcha.com/es/api/get-balance/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/api/get-balance/
`getBalance` devuelve los puntos restantes de la cuenta (1,000 puntos = ¥1), así como los saldos de participación del desarrollador y de recompensa por referidos (en yuanes). No cobra puntos y se usa a menudo para confirmar que `clientKey` es correcta.
- POST `https://api.yescaptcha.com/getBalance` (Endpoint global)
- POST `https://cn.yescaptcha.com/getBalance` (Endpoint China)
## Parámetros de la solicitud
| Campo | Tipo | Obligatorio | Descripción |
| --- | --- | --- | --- |
| `clientKey` | string | Sí | ClientKey de la cuenta |
```json
{
"clientKey": "YOUR_CLIENT_KEY"
}
```
## Respuesta
```json
{
"errorId": 0,
"balance": 1071810,
"softBalance": 36.0098,
"inviteBalance": 0,
"inviteBy": 0
}
```
| Campo | Tipo | Descripción |
| --- | --- | --- |
| `balance` | integer | Saldo de la cuenta, en puntos (1,000 puntos = ¥1). Debe ser mayor que 10 puntos para crear tareas |
| `softBalance` | number | Saldo de participación del desarrollador, en yuanes; consulta [participación del desarrollador](https://docs.yescaptcha.com/es/account/developer.md) |
| `inviteBalance` | number | Saldo de recompensa por referidos, en yuanes; consulta [recompensa por referidos](https://docs.yescaptcha.com/es/account/referral.md) |
| `inviteBy` | integer | ID de usuario de quien te invitó a registrarte; 0 si no hay |
| `keyQuotaRemaining` | integer | Límite de gasto restante de esta `clientKey` en el periodo actual, en puntos. Solo aparece en las `clientKey` que tienen un límite configurado; en ese caso `balance` es el menor entre el saldo de la cuenta y el límite restante. Las que no tienen límite no incluyen este campo |
Si `clientKey` es incorrecta, se devuelve `ERROR_KEY_DOES_NOT_EXIST`; si la `clientKey` tiene una lista blanca de IP y la solicitud proviene de una IP que no está en ella, se devuelve `ERROR_KEY_IP_NOT_ALLOWED`. `getBalance` se ve afectado por la [pausa automática](https://docs.yescaptcha.com/es/api/rate-limits.md): durante la pausa devuelve `ERROR_IP_BLOCKED_5MIN`.
## Ejemplos
**curl**
get-balance.sh
```bash
#!/usr/bin/env bash
# Check the balance. getBalance is free and is a quick way to verify your clientKey
set -euo pipefail
curl -s https://api.yescaptcha.com/getBalance \
-H 'Content-Type: application/json' \
-d "{\"clientKey\": \"${YESCAPTCHA_CLIENT_KEY}\"}"
echo
```
**Python**
get_balance.py
```python
"""Check the balance. getBalance is free and is a quick way to verify your clientKey."""
import os
import requests
CLIENT_KEY = os.environ["YESCAPTCHA_CLIENT_KEY"]
r = requests.post(
"https://api.yescaptcha.com/getBalance",
json={"clientKey": CLIENT_KEY},
timeout=30,
)
data = r.json()
if data.get("errorId"):
# e.g. ERROR_KEY_DOES_NOT_EXIST when the clientKey is wrong
print("error:", data.get("errorCode"), data.get("errorDescription"))
else:
print("balance (points):", data["balance"])
```
**Node.js**
get-balance.mjs
```js
// Check the balance. getBalance is free and is a quick way to verify your clientKey. Node.js 18+
const CLIENT_KEY = process.env.YESCAPTCHA_CLIENT_KEY;
const res = await fetch('https://api.yescaptcha.com/getBalance', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ clientKey: CLIENT_KEY }),
});
const data = await res.json();
if (data.errorId) {
// e.g. ERROR_KEY_DOES_NOT_EXIST when the clientKey is wrong
console.log('error:', data.errorCode, data.errorDescription);
} else {
console.log('balance (points):', data.balance);
}
```
---
# getSoftID — consultar tu ID de desarrollador
> POST /getSoftID devuelve tu ID de desarrollador (softID) y la participación del desarrollador acumulada. Incluye el softID en las solicitudes createTask que envía tu software para otros usuarios y obtendrás una participación.
Source: https://docs.yescaptcha.com/es/api/get-soft-id/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/api/get-soft-id/
`getSoftID` devuelve tu ID de desarrollador (`softID`) y la participación del desarrollador acumulada (en yuanes). Cuando otras personas usan tu software o extensión, incluye este ID en sus solicitudes `createTask` y recibirás una participación de lo que gasten. Reglas y retiros: [Participación del desarrollador](https://docs.yescaptcha.com/es/account/developer.md).
- POST `https://api.yescaptcha.com/getSoftID` (Endpoint global)
- POST `https://cn.yescaptcha.com/getSoftID` (Endpoint China)
## Parámetros de la solicitud
| Campo | Tipo | Obligatorio | Descripción |
| --- | --- | --- | --- |
| `clientKey` | string | Sí | Tu propio ClientKey (el del desarrollador) |
```json
{
"clientKey": "YOUR_CLIENT_KEY"
}
```
## Respuesta
```json
{
"errorId": 0,
"softID": 3,
"balance": 0.004
}
```
| Campo | Tipo | Descripción |
| --- | --- | --- |
| `softID` | integer | Tu ID de desarrollador |
| `balance` | number | Participación del desarrollador acumulada, en yuanes |
## Cómo usarlo
En las solicitudes `createTask` que envían los usuarios de tu software, añade el campo `softID` en el nivel superior:
```json
{
"clientKey": "THE_USERS_CLIENT_KEY",
"task": {
"type": "ImageToTextTaskOcrBase",
"body": "BASE64_IMAGE"
},
"softID": 3
}
```
> **Precaución:** Coloca `softID` en el nivel superior del cuerpo de la solicitud, al mismo nivel que `clientKey` y `task`, y respeta exactamente las mayúsculas y minúsculas. Dentro de `task` no tiene efecto.
`clientKey` es el ClientKey del propio usuario y los puntos se cobran al usuario; `softID` es tu ID de desarrollador.
---
# report — reportar resultados
> POST /report informa si el resultado de una tarea fue correcto; reporta tanto los éxitos como los fallos con honestidad. Los fallos de tipos de reconocimiento de imágenes reportados dentro de 1 hora desde la creación de la tarea se liquidan con reembolso tras unas 24 horas.
Source: https://docs.yescaptcha.com/es/api/report/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/api/report/
`report` sirve para decirnos si el resultado de un grupo de tareas fue correcto o no. **Reporta tanto los éxitos como los fallos.** Cuando reportas como incorrecto el resultado de un tipo de reconocimiento de imágenes, los casos que cumplen las condiciones reciben un reembolso de puntos tras unas 24 horas; los reportes también se usan para evaluar y mejorar el reconocimiento.
- POST `https://api.yescaptcha.com/report` (Endpoint global)
- POST `https://cn.yescaptcha.com/report` (Endpoint China)
## Parámetros de la solicitud
| Campo | Tipo | Obligatorio | Descripción |
| --- | --- | --- | --- |
| `id` | array of string | Sí | Lista de IDs de tarea; puedes reportar varias a la vez |
| `isSuccess` | boolean | Sí | `true` si el resultado fue correcto, `false` si fue incorrecto |
No se necesita `clientKey`: el ID de tarea ya identifica la tarea.
```json
{
"id": ["610ff5e0-68eb-11ef-95a6-22e70a0b794d", "65b88c06-68eb-11ef-8e9a-52540023ccb3"],
"isSuccess": false
}
```
## Respuesta
```json
{
"errorId": 0,
"status": "success"
}
```
## Reporta con honestidad
Los reportes sirven tanto para liquidar el reembolso como para evaluar y mejorar el reconocimiento, así que repórtalos según el resultado real:
- Reporta `isSuccess: true` para las tareas con resultado correcto y `false` para las incorrectas. Los reportes que solo marcan fallos, o que marcan todo como fallo sin importar el resultado, no se toman como referencia en las estadísticas ni en la liquidación.
- La tasa de fallos se calcula sobre todas las tareas que creaste en ese periodo, no solo sobre las que reportaste. Reportar más fallos no te da más reembolsos: si tu tasa de fallos es claramente superior a la del mismo periodo, el reembolso se calcula solo con la tasa de fallos de ese periodo.
- Cuando una verificación usa varias imágenes (por ejemplo, FunCaptcha pide 5 rondas) y no sabes cuál falló, puedes reportar todo el grupo de tareas como fallido; cuando la verificación se supera, reporta igualmente todo el grupo como exitoso.
## Reembolso tras reportar un fallo
- Solo 5 tipos de reconocimiento de imágenes admiten reembolso: `FunCaptchaClassification`, `HCaptchaClassification`, `ReCaptchaV2Classification`, `AwsClassification` y `bCaptchaClassification`.
- Solo cuentan los reportes hechos dentro de **1 hora** desde la creación de la tarea; cada tarea se reembolsa una sola vez.
- El reembolso no es inmediato: se liquida en conjunto **unas 24 horas después**.
- En la liquidación se compara con otros usuarios que tuvieron la misma pregunta en el mismo periodo; si tu tasa de fallos reportada es claramente superior a la de ese periodo, el reembolso se calcula con la tasa de fallos del periodo.
- Si tienes dudas sobre una liquidación, puedes [contactar con soporte](https://docs.yescaptcha.com/es/help/contact.md) para apelar.
En los tipos que devuelven token (reCAPTCHA, hCaptcha, Turnstile, FunCaptcha, etc.), el sitio de destino decide si el token es válido, por lo que el reporte no genera reembolso. Resumen de las reglas de cobro: [Facturación y reembolso de puntos](https://docs.yescaptcha.com/es/getting-started/billing.md).
---
# useragent — obtener el User-Agent
> GET https://api.yescaptcha.com/useragent devuelve el User-Agent del navegador que se recomienda usar (texto plano). El campo userAgent de las tareas de hCaptcha solo acepta este valor.
Source: https://docs.yescaptcha.com/es/api/useragent/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/api/useragent/
`/useragent` devuelve el User-Agent del navegador que se recomienda usar actualmente, en texto plano. No requiere `clientKey` y no cobra puntos. El campo `userAgent` de las tareas de [hCaptcha](https://docs.yescaptcha.com/es/tasks/hcaptcha.md) solo acepta este valor; usarlo también al visitar el sitio de destino ayuda a que el token sea aceptado con más facilidad.
- GET `https://api.yescaptcha.com/useragent` (Endpoint global)
- GET `https://cn.yescaptcha.com/useragent` (Endpoint China)
## Ejemplo
```bash
curl -s https://api.yescaptcha.com/useragent
```
Respuesta (valor del 2026-10-15; cambia con las versiones del navegador):
```text
Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/155.0.0.0 Safari/537.36
```
> **Nota:** El valor se actualiza con el tiempo. No lo escribas fijo en el código; basta con obtenerlo una vez al iniciar el programa.
- Si el resultado incluye un `userAgent`, usa ese valor al enviar el token.
---
# Códigos de error
> Significado y forma de resolver todos los códigos de error de la API de YesCaptcha: formato de la solicitud, cuenta y saldo, tareas simultáneas y pausas, resultado de la tarea, parámetros del sitio, imágenes, proxy y servidor. Las solicitudes que devuelven error no cobran puntos.
Source: https://docs.yescaptcha.com/es/api/errors/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/api/errors/
Cuando la API falla, devuelve `errorId: 1`; `errorCode` es el código de error y `errorDescription` es la descripción en texto. Las solicitudes que devuelven error no cobran puntos: si el error ocurre al crear la tarea no se cobra nada, y si el reconocimiento falla o se agota el tiempo después de crearla, los puntos se reembolsan automáticamente.
> **Consejo:** En tu programa, decide según `errorCode`, no según el texto de `errorDescription`, ya que la descripción puede cambiar.
```json
{
"errorId": 1,
"errorCode": "ERROR_ZERO_BALANCE",
"errorDescription": "帐户余额不足"
}
```
## Cómo manejar los errores
1. **Los errores de parámetros** (formato de la solicitud, ClientKey, tipo de tarea, parámetros del sitio, imágenes) no cambian al reenviar la solicitud; primero corrígela.
2. **Los fallos de reconocimiento y los tiempos agotados** (`ERROR_CAPTCHA_UNSOLVABLE`, `ERROR_TASK_TIMEOUT`) se pueden resolver creando una tarea nueva.
3. Tras un error, **deja de consultar** ese `taskId`; no reenvíes la misma solicitud a alta frecuencia.
4. Con los errores marcados como “cuenta para la pausa automática”, si un mismo `clientKey` acumula 100 en un minuto, se pausa la creación de tareas durante 5 minutos. Los marcados como “caché” no cuentan, pero mientras dura la caché las solicitudes idénticas devuelven directamente el mismo error. Más detalles en [Límite de tareas simultáneas y pausa automática](https://docs.yescaptcha.com/es/api/rate-limits.md).
## Todos los códigos de error
### Formato de la solicitud
| Código de error | Significado | Qué hacer |
| --- | --- | --- |
| `ERROR_REQUIRED_FIELDS` | Falta un campo obligatorio (como `clientKey`, o `websiteURL` / `websiteKey` para el tipo de tarea), o el cuerpo de la solicitud no es JSON | Añade los campos que faltan indicados en la página del tipo de tarea, y envía JSON con `POST` y `Content-Type: application/json` |
| `ERROR_REQUEST_FORMATS` (Cuenta para la pausa) | El cuerpo de la solicitud no es un JSON válido | Genera el cuerpo con una biblioteca de JSON en lugar de concatenar cadenas; el JSON no puede contener comentarios `//` |
| `ERROR_TASK_ABSENT` (Cuenta para la pausa) | Falta el campo `task` en una llamada a `createTask` | Coloca los parámetros de la tarea en un objeto `task`. Con Python requests usa `json=data`, no `data=data` |
| `ERROR_TASK_NOT_SUPPORTED` (Cuenta para la pausa) | `task.type` está mal escrito o el tipo ya fue dado de baja | Copia el nombre del tipo desde "Tipos de tarea y precios"; los nombres distinguen entre mayúsculas y minúsculas |
| `ERROR_PAGE_NOT_FOUND` | La ruta solicitada no existe | Revisa la URL del endpoint, p. ej., `https://api.yescaptcha.com/createTask`; los nombres de los métodos distinguen entre mayúsculas y minúsculas |
| `ERROR_BAD_REQUEST` | No se puede procesar la solicitud, normalmente por un método HTTP incorrecto (GET en lugar de POST) o por valores de parámetros no válidos | Envía JSON con `POST` y revisa los tipos y valores de los parámetros |
| `ERROR_ILLEGAL_PARAMETERS` | El valor de un parámetro no es válido. Es típico en la página de verificación de Cloudflare: `websiteURL` no es una URL pública que empiece por `http://` / `https://`, `postData` no es un objeto, o `requiredCookies` no es un arreglo de cadenas (lo devuelve createTask, sin cobro de puntos); o no se pudo resolver el dominio de destino a través del proxy (lo devuelve getTaskResult, con reembolso de puntos automático) | Corrige el valor según la tabla de parámetros de la página del tipo de tarea. Si no se pudo resolver el dominio, revisa la ortografía de la URL y si el proxy puede acceder al sitio |
### Cuenta y saldo
| Código de error | Significado | Qué hacer |
| --- | --- | --- |
| `ERROR_KEY_DOES_NOT_EXIST` (Cuenta para la pausa) | El `clientKey` no existe: se añadieron o perdieron caracteres al copiarlo, o la clave se restableció en el Panel | Vuelve a copiar la clave desde el Panel de yescaptcha.com, sin espacios ni saltos de línea |
| `ERROR_KEY_EXPIRED` (Cuenta para la pausa) | El `clientKey` ha expirado (lo devuelven createTask y getBalance, sin cobro de puntos). Puede ser que no se haya usado durante mucho tiempo y el sistema haya fijado una fecha de expiración para proteger la cuenta (se envía un recordatorio por correo antes de que expire), o que haya pasado la fecha de expiración configurada para este `clientKey` | Inicia sesión en el Panel de yescaptcha.com. Si expiró por llevar mucho tiempo sin usarse, genera un nuevo `clientKey`; el saldo se transfiere automáticamente al nuevo. Si se configuró una fecha de expiración, cámbiala o usa otro `clientKey`. Después, actualiza tu programa con el nuevo `clientKey` |
| `ERROR_KEY_IP_NOT_ALLOWED` | Este `clientKey` tiene una lista de IP permitidas y la IP desde la que se envió la solicitud no está en ella (lo devuelven createTask y getBalance, no se hace cobro de puntos, no cuenta para la pausa automática) | Inicia sesión en el Panel de yescaptcha.com y agrega la IP pública de la máquina que envía las solicitudes a la lista de IP permitidas de este `clientKey`, o usa otro `clientKey`. Si varias máquinas llaman a la API, agrega la IP pública de cada una (es la IP que llama a la API de YesCaptcha, no el proxy de los parámetros de la tarea) |
| `ERROR_KEY_QUOTA_EXCEEDED` | Este `clientKey` tiene un límite de gasto y lo que queda de él en el período actual es menor que el costo de esta tarea (lo devuelve createTask, no se hace cobro de puntos, no cuenta para la pausa automática). El límite cuenta los puntos realmente cobrados; los puntos reembolsados por tareas fallidas o con tiempo agotado vuelven al límite | Inicia sesión en el Panel de yescaptcha.com y aumenta el límite de este `clientKey`, espera al siguiente período (se restablece cada día, cada lunes o el día 1 de cada mes, hora de Beijing; un límite único no se restablece), o usa otro `clientKey`. `getBalance` devuelve el límite restante de este `clientKey` (`keyQuotaRemaining`) |
| `ERROR_ZERO_BALANCE` | Saldo insuficiente. El saldo debe ser superior a 10 puntos para crear una tarea | Recarga y vuelve a intentarlo. Usa `getBalance` para consultar el saldo |
### Tareas simultáneas y pausas
| Código de error | Significado | Qué hacer |
| --- | --- | --- |
| `ERROR_THREADS_MAXIMUM` (A veces cuenta para la pausa) | Hay demasiadas tareas de este tipo en curso para la cuenta. `limit` en la respuesta es el límite actual. La solicitud no se procesó y no hubo cobro de puntos | Espera a que terminen las solicitudes en curso, o espera 1–2 segundos y vuelve a intentarlo; limita el número de solicitudes que esperan al mismo tiempo |
| `ERROR_IP_BLOCKED_5MIN` | Este `clientKey` generó demasiados errores en poco tiempo y se aplicó una pausa automática. `retryAfter` son los segundos restantes y `blockReason` es el error que la causó | Corrige la solicitud según `blockReason` y espera `retryAfter` segundos; enviar solicitudes durante la pausa no la prolonga |
| `ERROR_NO_SLOT_AVAILABLE` | El servicio de resolución está temporalmente saturado. Cuando lo devuelve createTask, no se cobra nada; una tarea que esperó demasiado en la cola también lo devuelve desde getTaskResult, y se le hace un reembolso de puntos automático | Espera unos segundos y crea la tarea de nuevo |
### Tareas y resultados
| Código de error | Significado | Qué hacer |
| --- | --- | --- |
| `ERROR_TASKID_INVALID` (Cuenta para la pausa) | El `taskId` no existe, ha expirado (los resultados se conservan unos 10 minutos), pertenece a otro `clientKey` o se creó en el otro endpoint | Deja de hacer consultas periódicas (polling) de esta tarea. Consulta con el mismo endpoint y el mismo `clientKey` con el que se creó |
| `ERROR_TASK_TIMEOUT` | La tarea no terminó a tiempo (normalmente 110 segundos); los puntos se reembolsaron automáticamente | Crea una tarea nueva; si sigue agotando el tiempo, prueba otro tipo de tarea para el mismo captcha |
| `ERROR_CAPTCHA_UNSOLVABLE` | Esta vez no se pudo resolver el captcha; los puntos se reembolsaron. No cuenta para la pausa automática | Crea una tarea nueva. Si sigue fallando, revisa `websiteURL`, `websiteKey` y los demás parámetros, o prueba otro tipo de tarea para el mismo captcha |
| `ERROR_SETTLEMENT_FAILED` (Cuenta para la pausa) | El saldo era insuficiente al momento del cobro, por lo que no se devolvió ningún resultado | Recarga y crea una tarea nueva |
| `ERROR_NO_SUCH_CAPCHA_ID` | La tarea ya no es válida | Deja de hacer consultas periódicas (polling) de esta tarea y crea una nueva |
| `ERROR_RECAPTCHA_TIMEOUT` | Se agotó el tiempo al resolver el captcha; los puntos se reembolsaron | Crea una tarea nueva |
### Parámetros del sitio de destino
| Código de error | Significado | Qué hacer |
| --- | --- | --- |
| `ERROR_RECAPTCHA_INVALID_SITEKEY` (En caché, no cuenta para la pausa) | El `websiteKey` no es válido | Vuelve a buscar el sitekey en la página (consulta las guías para encontrar parámetros). Las solicitudes idénticas devuelven este error directamente durante el periodo de caché, con `cached: true` |
| `ERROR_RECAPTCHA_INVALID_DOMAIN` (En caché, no cuenta para la pausa) | El dominio de `websiteURL` no coincide con el `websiteKey` | Establece `websiteURL` con la página que muestra el captcha |
| `ERROR_INVALID_KEY_TYPE` (En caché, no cuenta para la pausa) | El sitekey pertenece a otro captcha, por ejemplo una clave de v3 usada con un tipo de tarea de v2 | Identifica primero el captcha (consulta "Identificar el tipo de captcha") y elige el tipo de tarea correspondiente; para v2 invisible indica `isInvisible` |
| `ERROR_DOMAIN_NOT_ALLOWED` (En caché, no cuenta para la pausa) | Este sitio no es compatible | Prueba otro tipo de tarea para el mismo captcha o contacta a soporte |
| `ERROR_HIGH_DEMAND_DOMAIN` (Cuenta para la pausa) | Este sitio no es compatible | Deja de enviar tareas para este sitio y contacta a soporte |
| `ERROR_FAILED_LOADING_WIDGET` | No se pudo cargar el captcha con los parámetros indicados | Revisa `websiteURL` y `websiteKey`; en los tipos de tarea con proxy propio, comprueba que el proxy pueda acceder al sitio |
### Imágenes
| Código de error | Significado | Qué hacer |
| --- | --- | --- |
| `ERROR_ZERO_CAPTCHA_FILESIZE` (Cuenta para la pausa) | La imagen está vacía o es demasiado pequeña | Comprueba que los datos en Base64 estén completos y no tengan el prefijo `data:image/...;base64,` |
| `ERROR_TOO_BIG_CAPTCHA_FILESIZE` (Cuenta para la pausa) | La imagen es demasiado grande | Comprime o reduce la imagen; el cuerpo completo de la solicitud no debe superar 6 MB |
| `ERROR_IMAGE_TYPE_NOT_SUPPORTED` (Cuenta para la pausa) | El formato de la imagen no es compatible, o la imagen no es de las que este tipo de tarea puede procesar. Una sola aparición pausa la clave durante 30 minutos | Usa JPG o PNG y asegúrate de que la imagen corresponda al tipo de tarea; por ejemplo, el reconocimiento de imágenes de reCAPTCHA requiere 100x100, 300x300 o 450x450 |
| `ERROR_ILLEGAL_IMAGE` (Cuenta para la pausa) | El tamaño de la imagen no cumple los requisitos de este tipo de tarea | Cambia el tamaño de la imagen como se describe en la página del tipo de tarea |
| `ERROR_PARSE_IMAGE_FAIL` | No se pudo decodificar la imagen, a menudo porque el Base64 está truncado o tiene un prefijo | Revisa la codificación Base64 y elimina el prefijo `data:` y los saltos de línea |
| `ERROR_UNKNOWN_QUESTION` | La `question` es incorrecta, o esta pregunta aún no es compatible | Compárala con la lista de preguntas de la página del tipo de tarea. Si una pregunta no es compatible, contacta a soporte; las preguntas nuevas normalmente se admiten en 3 días hábiles |
| `ERROR_UNKNOW_450x450_QUESTION` | Esta pregunta aún no es compatible con imágenes de 4x4 (450x450) | Recarga el desafío en la página para obtener otra pregunta |
### Proxies
| Código de error | Significado | Qué hacer |
| --- | --- | --- |
| `ERROR_PROXY_CONNECT_REFUSED` | El proxy rechazó la conexión | Revisa la dirección, el puerto y el protocolo del proxy, y asegúrate de que acepte conexiones externas (no una dirección local como 127.0.0.1) |
| `ERROR_PROXY_CONNECT_TIMEOUT` | Se agotó el tiempo al conectar con el proxy | Usa un proxy más estable |
| `ERROR_PROXY_READ_TIMEOUT` | Se agotó el tiempo al leer datos a través del proxy | Usa un proxy más rápido |
| `ERROR_PROXY_BANNED` | El proxy no está disponible, o su IP está bloqueada por el sitio de destino | Usa otro proxy |
| `ERROR_PROXY_INCORRECT` | Los parámetros del proxy tienen un formato incorrecto | Revisa el formato de `proxyType`, `proxyAddress`, `proxyPort` (o de la cadena `proxy`) |
| `ERROR_PROXY_TRANSPARENT` | El proxy es transparente y expone la IP real | Usa un proxy anónimo (de alto anonimato) |
| `ERROR_PROXY_NOT_AUTHORISED` | El usuario o la contraseña del proxy son incorrectos | Revisa `proxyLogin` y `proxyPassword` (o las credenciales en la cadena `proxy`) |
| `ERROR_PROXY_TLS_ERROR` | Falló el handshake TLS con el proxy, a menudo porque `proxyType` es incorrecto (por ejemplo, https indicado para un proxy http) | Revisa el protocolo del proxy |
| `ERROR_PROXY_CONNECTION_FAILED` | No se pudo conectar con el servidor proxy | Revisa la dirección y el puerto del proxy y asegúrate de que funcione correctamente |
### Servidor
| Código de error | Significado | Qué hacer |
| --- | --- | --- |
| `ERROR_SERVICE_UNAVALIABLE` | El servicio no está disponible temporalmente (el código se escribe `UNAVALIABLE`) | Inténtalo de nuevo más tarde; contacta a soporte si persiste |
| `ERROR_INTERNAL_SERVER_ERROR` | Ocurrió un error interno del servidor | Vuelve a intentarlo más tarde; si persiste, contacta con Soporte e indica el `taskId` |
| `ERROR_UNKNOWN` | Un error sin clasificar | Vuelve a intentarlo más tarde; si persiste, contacta con Soporte e indica el `taskId` |
## Campos adicionales
Algunas respuestas de error incluyen campos adicionales:
| Campo | Aparece en | Descripción |
| --- | --- | --- |
| `retryAfter` | `ERROR_IP_BLOCKED_5MIN`, errores en caché | Segundos que faltan por esperar |
| `blockReason` | `ERROR_IP_BLOCKED_5MIN` | Código de error que provocó la pausa |
| `blockDetail` | `ERROR_IP_BLOCKED_5MIN` | Tipo, URL y sitekey de las solicitudes que provocaron la pausa, para facilitar la localización |
| `cached` | Errores en caché | `true` indica que es un resultado en caché y no hubo reconocimiento real |
| `badRequest` | Errores en caché | Parámetros que coincidieron con la caché |
| `limit` | `ERROR_THREADS_MAXIMUM` | Tu límite actual de tareas simultáneas |
Las reglas sobre el idioma de `errorDescription` están en [Solicitudes y respuestas](https://docs.yescaptcha.com/es/api/overview.md).
---
# Límite de tareas simultáneas y pausa automática
> Límite de tareas simultáneas de YesCaptcha (ERROR_THREADS_MAXIMUM, sin cobro de puntos y sin contar para la pausa), pausa automática por exceso de errores (100 en un minuto pausan 5 minutos, ERROR_IP_BLOCKED_5MIN) y caché de parámetros no válidos (cached).
Source: https://docs.yescaptcha.com/es/api/rate-limits/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/api/rate-limits/
Para mantener la velocidad de reconocimiento para todos los usuarios, YesCaptcha tiene tres reglas de protección: limita por cuenta el **número de tareas en proceso a la vez** (límite de tareas simultáneas); pausa durante unos minutos un `clientKey` que genera **demasiados errores en poco tiempo** (pausa automática); y devuelve directamente el error original, durante un tiempo, para los **parámetros ya considerados no válidos** (caché de parámetros no válidos). En ninguno de los tres casos se cobran puntos.
## Límite de tareas simultáneas
Limitamos, por cuenta y por tipo de tarea, el número de tareas que se procesan al mismo tiempo. Se limita la simultaneidad, no el número de solicitudes por minuto.
- Una tarea cuenta como “en proceso” desde que llamas a `createTask` hasta que esa llamada devuelve la respuesta. Los tipos de reconocimiento de imágenes devuelven el resultado directamente en `createTask`, así que **tareas simultáneas ≈ tareas enviadas por segundo × duración de cada tarea**. Por ejemplo, con 0.5 segundos por tarea y 40 tareas por segundo, hay unas 20 tareas simultáneas.
- Las solicitudes de una misma cuenta se suman; cada tipo de tarea se cuenta por separado.
- Las solicitudes que superan el límite devuelven de inmediato `ERROR_THREADS_MAXIMUM`, y el campo `limit` de la respuesta indica tu límite actual. **No se cobran puntos ni cuenta para la pausa automática.**
- Cuando los servidores de reconocimiento están saturados, a la cuenta que más tiempo de reconocimiento consume se le **reduce temporalmente a la mitad** el límite de ese tipo de tarea, y **se restablece automáticamente a los 10 minutos**. Solo reduce la velocidad; no pausa la cuenta.
- Si necesitas un límite mayor, [contacta con Soporte](https://docs.yescaptcha.com/es/help/contact.md). Cuando se definan los límites predeterminados de cada tipo, se publicarán en esta página y en el [registro de actualizaciones del servicio](https://docs.yescaptcha.com/es/changelog.md).
```json
{
"errorId": 1,
"errorCode": "ERROR_THREADS_MAXIMUM",
"errorDescription": "This account already has 30 tasks of this type in progress, which is the limit. Lower the concurrency and wait for pending requests to return before sending more; rejected requests are not charged and do not lead to a block.",
"limit": 30
}
```
(Los números del ejemplo son solo ilustrativos.)
### Recomendaciones
1. En tu programa, limita el número de solicitudes que esperan resultado a la vez, por ejemplo con un semáforo (Semaphore) o un pool de hilos de tamaño fijo, en lugar de controlar solo cuántas envías por segundo.
2. Tras recibir `ERROR_THREADS_MAXIMUM`, espera a que las solicitudes ya enviadas devuelvan su respuesta antes de enviar nuevas, o espera de 1 a 2 segundos y vuelve a intentarlo. No reintentes de inmediato en un bucle.
3. Envía las tareas por lotes de forma uniforme; no envíes miles de tareas de golpe.
Ejemplo en Python (asyncio):
```python
import asyncio
import os
import aiohttp
CLIENT_KEY = os.environ["YESCAPTCHA_CLIENT_KEY"]
LIMIT = 15 # below your concurrency limit
sem = asyncio.Semaphore(LIMIT)
async def solve(session, task):
async with sem: # at most LIMIT requests in progress at a time
result = {}
for attempt in range(5):
async with session.post(
"https://api.yescaptcha.com/createTask",
json={"clientKey": CLIENT_KEY, "task": task},
) as resp:
result = await resp.json()
if result.get("errorCode") != "ERROR_THREADS_MAXIMUM":
return result
await asyncio.sleep(1 + attempt) # over the limit: wait and retry
return result
```
## Pausa automática
Si un mismo `clientKey` genera muchas solicitudes con error en poco tiempo, se le pausa automáticamente la creación de tareas:
| Condición | Duración de la pausa |
| --- | --- |
| 100 de los errores indicados abajo dentro del mismo minuto natural | 5 minutos |
| 1 vez `ERROR_IMAGE_TYPE_NOT_SUPPORTED` | 30 minutos |
| 1000 coincidencias con la “caché de parámetros no válidos” dentro del mismo minuto natural | 5 minutos |
Errores que cuentan para la pausa:
- [`ERROR_REQUEST_FORMATS`](https://docs.yescaptcha.com/es/api/errors.md#ERROR_REQUEST_FORMATS)
- [`ERROR_TASK_ABSENT`](https://docs.yescaptcha.com/es/api/errors.md#ERROR_TASK_ABSENT)
- [`ERROR_TASK_NOT_SUPPORTED`](https://docs.yescaptcha.com/es/api/errors.md#ERROR_TASK_NOT_SUPPORTED)
- [`ERROR_KEY_DOES_NOT_EXIST`](https://docs.yescaptcha.com/es/api/errors.md#ERROR_KEY_DOES_NOT_EXIST)
- [`ERROR_KEY_EXPIRED`](https://docs.yescaptcha.com/es/api/errors.md#ERROR_KEY_EXPIRED)
- [`ERROR_TASKID_INVALID`](https://docs.yescaptcha.com/es/api/errors.md#ERROR_TASKID_INVALID)
- [`ERROR_SETTLEMENT_FAILED`](https://docs.yescaptcha.com/es/api/errors.md#ERROR_SETTLEMENT_FAILED)
- [`ERROR_HIGH_DEMAND_DOMAIN`](https://docs.yescaptcha.com/es/api/errors.md#ERROR_HIGH_DEMAND_DOMAIN)
- [`ERROR_ZERO_CAPTCHA_FILESIZE`](https://docs.yescaptcha.com/es/api/errors.md#ERROR_ZERO_CAPTCHA_FILESIZE)
- [`ERROR_TOO_BIG_CAPTCHA_FILESIZE`](https://docs.yescaptcha.com/es/api/errors.md#ERROR_TOO_BIG_CAPTCHA_FILESIZE)
- [`ERROR_IMAGE_TYPE_NOT_SUPPORTED`](https://docs.yescaptcha.com/es/api/errors.md#ERROR_IMAGE_TYPE_NOT_SUPPORTED)
- [`ERROR_ILLEGAL_IMAGE`](https://docs.yescaptcha.com/es/api/errors.md#ERROR_ILLEGAL_IMAGE)
No cuenta el `ERROR_THREADS_MAXIMUM` devuelto por superar el límite de tareas simultáneas de la cuenta (con el campo `limit`); el error del mismo nombre devuelto cuando el servicio de reconocimiento está saturado (sin `limit`) sí cuenta. No cuentan los fallos de reconocimiento (`ERROR_CAPTCHA_UNSOLVABLE`), el saldo insuficiente (`ERROR_ZERO_BALANCE`), los campos que faltan (`ERROR_REQUIRED_FIELDS`), las preguntas no admitidas (`ERROR_UNKNOWN_QUESTION`), entre otros.
Durante la pausa:
- Solo se ven afectados `createTask` y `getBalance`, que devuelven `ERROR_IP_BLOCKED_5MIN`. `getTaskResult` no se ve afectado: las tareas creadas antes de la pausa se pueden consultar con normalidad.
- La respuesta incluye `retryAfter` (segundos restantes), `blockReason` (el código de error que provocó la pausa) y `blockDetail` (tipo, URL y sitekey de esas solicitudes); corrige tu programa según estos datos.
- Seguir enviando solicitudes no alarga la pausa. Termina automáticamente al vencer; no es necesario contactar con Soporte.
- En el Panel de [yescaptcha.com](https://yescaptcha.com/) puedes ver el registro de pausas de las últimas 24 horas.
```json
{
"errorId": 1,
"errorCode": "ERROR_IP_BLOCKED_5MIN",
"errorDescription": "...",
"retryAfter": 182,
"blockReason": "ERROR_TASK_NOT_SUPPORTED"
}
```
## Caché de parámetros no válidos
Algunos errores dependen de los parámetros de la solicitud, y reenviar los mismos parámetros dará el mismo resultado:
- [`ERROR_RECAPTCHA_INVALID_SITEKEY`](https://docs.yescaptcha.com/es/api/errors.md#ERROR_RECAPTCHA_INVALID_SITEKEY)
- [`ERROR_RECAPTCHA_INVALID_DOMAIN`](https://docs.yescaptcha.com/es/api/errors.md#ERROR_RECAPTCHA_INVALID_DOMAIN)
- [`ERROR_INVALID_KEY_TYPE`](https://docs.yescaptcha.com/es/api/errors.md#ERROR_INVALID_KEY_TYPE)
- [`ERROR_DOMAIN_NOT_ALLOWED`](https://docs.yescaptcha.com/es/api/errors.md#ERROR_DOMAIN_NOT_ALLOWED)
Estos errores no cuentan para la pausa automática, sino que se guardan en caché en todo el sitio: tras la primera determinación se cachean 2 minutos, y si se vuelven a confirmar dentro de 1 hora, se cachean 10 minutos. Mientras dura la caché, las solicitudes idénticas (mismo tipo de tarea y `websiteKey`, o mismo dominio del sitio) devuelven directamente el error original, sin cobro de puntos, y la respuesta incluye `"cached": true`, `retryAfter` (segundos restantes de la caché) y `badRequest` (el parámetro coincidente). Al corregir el `websiteKey` o cambiar el tipo de tarea, el cambio surte efecto de inmediato.
## Diferencias entre el límite de tareas simultáneas y la pausa automática
| | Límite de tareas simultáneas | Pausa automática |
| --- | --- | --- |
| Causa | Demasiadas tareas en proceso a la vez | Demasiadas solicitudes con error en poco tiempo |
| Comportamiento | Solo se rechaza la parte que excede el límite, con `ERROR_THREADS_MAXIMUM` | Se pausa la creación de tareas de este `clientKey`, con `ERROR_IP_BLOCKED_5MIN` |
| Recuperación | Puedes enviar nuevas en cuanto termine el procesamiento de otras; la reducción temporal a la mitad se restablece a los 10 minutos | Se restablece automáticamente al vencer |
| Cobro de puntos | No se cobra | No se cobra |
---
# Tipos de tarea y precios
> Precios (en puntos; 1,000 puntos = ¥1) y modo de respuesta de todos los tipos de tarea públicos de YesCaptcha. Tokens para reCAPTCHA, hCaptcha y Turnstile, cookies para la página de verificación de Cloudflare, y resultados de reconocimiento para texto en imágenes y reconocimiento de imágenes.
Source: https://docs.yescaptcha.com/es/tasks/ · Last verified: 2026-10-19
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/tasks/
Cada tarea se cobra con un número fijo de puntos según su tipo (1,000 puntos = ¥1); las tareas fallidas o que superan el tiempo de espera se reembolsan automáticamente. La tabla lista todos los tipos de tarea públicos y se puede buscar por nombre. Versión legible por máquina: [/data/task-types.json](https://docs.yescaptcha.com/data/task-types.json).
| Captcha | Tipo de tarea | Precio | Modo |
| --- | --- | --- | --- |
| [reCAPTCHA v2](https://docs.yescaptcha.com/es/tasks/recaptcha-v2.md) | `NoCaptchaTaskProxyless` | $2.25 / 1k; 15 puntos/tarea · ¥15 / 1k | Asíncrono |
| [reCAPTCHA v2](https://docs.yescaptcha.com/es/tasks/recaptcha-v2.md) | `RecaptchaV2TaskProxyless` | $3.00 / 1k; 20 puntos/tarea · ¥20 / 1k | Asíncrono |
| [reCAPTCHA v2](https://docs.yescaptcha.com/es/tasks/recaptcha-v2.md) | `NoCaptchaTask` Proxy propio | $2.25 / 1k; 15 puntos/tarea · ¥15 / 1k | Asíncrono |
| [reCAPTCHA v2](https://docs.yescaptcha.com/es/tasks/recaptcha-v2.md) | `RecaptchaV2EnterpriseTaskProxyless` | $3.00 / 1k; 20 puntos/tarea · ¥20 / 1k | Asíncrono |
| [reCAPTCHA v2](https://docs.yescaptcha.com/es/tasks/recaptcha-v2.md) | `RecaptchaV2EnterpriseTask` Proxy propio | $3.00 / 1k; 20 puntos/tarea · ¥20 / 1k | Asíncrono |
| [reCAPTCHA v3](https://docs.yescaptcha.com/es/tasks/recaptcha-v3.md) | `RecaptchaV3TaskProxyless` | $3.00 / 1k; 20 puntos/tarea · ¥20 / 1k | Asíncrono |
| [reCAPTCHA v3](https://docs.yescaptcha.com/es/tasks/recaptcha-v3.md) | `RecaptchaV3TaskProxylessM1` | $3.75 / 1k; 25 puntos/tarea · ¥25 / 1k | Asíncrono |
| [reCAPTCHA v3](https://docs.yescaptcha.com/es/tasks/recaptcha-v3.md) | `RecaptchaV3TaskProxylessM1S7` | $4.50 / 1k; 30 puntos/tarea · ¥30 / 1k | Asíncrono |
| [reCAPTCHA v3](https://docs.yescaptcha.com/es/tasks/recaptcha-v3.md) | `RecaptchaV3TaskProxylessM1S9` | $5.25 / 1k; 35 puntos/tarea · ¥35 / 1k | Asíncrono |
| [reCAPTCHA v3](https://docs.yescaptcha.com/es/tasks/recaptcha-v3.md) | `RecaptchaV3EnterpriseTask` | $3.00 / 1k; 20 puntos/tarea · ¥20 / 1k | Asíncrono |
| [reCAPTCHA v3](https://docs.yescaptcha.com/es/tasks/recaptcha-v3.md) | `RecaptchaV3EnterpriseTaskM1` | $3.75 / 1k; 25 puntos/tarea · ¥25 / 1k | Asíncrono |
| [hCaptcha](https://docs.yescaptcha.com/es/tasks/hcaptcha.md) | `HCaptchaTaskProxyless` | $4.50 / 1k; 30 puntos/tarea · ¥30 / 1k | Asíncrono |
| [hCaptcha](https://docs.yescaptcha.com/es/tasks/hcaptcha.md) | `HCaptchaTaskProxylessM1` | $4.50 / 1k; 30 puntos/tarea · ¥30 / 1k | Asíncrono |
| [hCaptcha](https://docs.yescaptcha.com/es/tasks/hcaptcha.md) | `HCaptchaTask` Proxy propio | $2.25 / 1k; 15 puntos/tarea · ¥15 / 1k | Asíncrono |
| [Cloudflare Turnstile](https://docs.yescaptcha.com/es/tasks/turnstile.md) | `TurnstileTaskProxyless` | $3.75 / 1k; 25 puntos/tarea · ¥25 / 1k | Asíncrono |
| [Cloudflare Turnstile](https://docs.yescaptcha.com/es/tasks/turnstile.md) | `TurnstileTaskProxylessM1` | $4.50 / 1k; 30 puntos/tarea · ¥30 / 1k | Asíncrono |
| [Cloudflare Turnstile](https://docs.yescaptcha.com/es/tasks/turnstile.md) | `TurnstileTask` Proxy propio | $3.75 / 1k; 25 puntos/tarea · ¥25 / 1k | Asíncrono |
| [Página de verificación de Cloudflare](https://docs.yescaptcha.com/es/tasks/cloudflare-challenge.md) | `CloudFlareTaskS2` Proxy propio | $3.75 / 1k; 25 puntos/tarea · ¥25 / 1k | Asíncrono |
| [Página de verificación de Cloudflare](https://docs.yescaptcha.com/es/tasks/cloudflare-challenge.md) | `CloudFlareTaskS3` Proxy propio | $3.00 / 1k; 20 puntos/tarea · ¥20 / 1k | Asíncrono |
| [Imagen a texto](https://docs.yescaptcha.com/es/tasks/image-to-text.md) | `ImageToTextTaskOcrBase` | $0.30 / 1k; 2 puntos/tarea · ¥2 / 1k | Síncrono |
| [Imagen a texto](https://docs.yescaptcha.com/es/tasks/image-to-text.md) | `ImageToTextTaskMuggle` | $0.30 / 1k; 2 puntos/tarea · ¥2 / 1k | Síncrono |
| [Imagen a texto](https://docs.yescaptcha.com/es/tasks/image-to-text.md) | `ImageToTextTask` | $0.60 / 1k; 4 puntos/tarea · ¥4 / 1k | Asíncrono |
| [Imagen a texto](https://docs.yescaptcha.com/es/tasks/image-to-text.md) | `ImageToTextTaskM1` | $2.25 / 1k; 15 puntos/tarea · ¥15 / 1k | Asíncrono |
| [Reconocimiento de imágenes de reCAPTCHA v2](https://docs.yescaptcha.com/es/tasks/recaptcha-classification.md) | `ReCaptchaV2Classification` | $0.90 / 1k; 6 puntos/tarea · ¥6 / 1k | Síncrono |
| [Reconocimiento de imágenes de hCaptcha](https://docs.yescaptcha.com/es/tasks/hcaptcha-classification.md) | `HCaptchaClassification` | $1.20 / 1k; 8 puntos/tarea · ¥8 / 1k | Síncrono |
| [Reconocimiento de imágenes de FunCaptcha](https://docs.yescaptcha.com/es/tasks/funcaptcha-classification.md) | `FunCaptchaClassification` | $0.45 / 1k; 3 puntos/tarea · ¥3 / 1k | Síncrono |
| [Reconocimiento de imágenes de AWS WAF / bCaptcha](https://docs.yescaptcha.com/es/tasks/aws-bcaptcha-classification.md) | `AwsClassification` | $1.20 / 1k; 8 puntos/tarea · ¥8 / 1k | Síncrono |
| [Reconocimiento de imágenes de AWS WAF / bCaptcha](https://docs.yescaptcha.com/es/tasks/aws-bcaptcha-classification.md) | `bCaptchaClassification` | $1.20 / 1k; 8 puntos/tarea · ¥8 / 1k | Síncrono |
Los precios en dólares son estimaciones con US$1 ≈ ¥6.67 (2026-10-27). Las tareas se cobran en puntos: 1,000 puntos = ¥1 cuando recargas en CNY; las recargas en dólares (PayPal, criptomonedas) se convierten a CNY al tipo de cambio del momento del pago y luego a puntos.
## ¿Cuál necesito?
| Lo que quieres hacer | Qué usar | Qué obtienes |
| --- | --- | --- |
| Obtener un token y enviarlo directamente, sin hacer clic en imágenes | [reCAPTCHA v2](https://docs.yescaptcha.com/es/tasks/recaptcha-v2.md), [reCAPTCHA v3](https://docs.yescaptcha.com/es/tasks/recaptcha-v3.md), [hCaptcha](https://docs.yescaptcha.com/es/tasks/hcaptcha.md), [Turnstile](https://docs.yescaptcha.com/es/tasks/turnstile.md) | Un token, de forma asíncrona |
| Pasar la página de espera de Cloudflare (“Un momento…”) | [Página de verificación de Cloudflare](https://docs.yescaptcha.com/es/tasks/cloudflare-challenge.md) | Cookies, User-Agent y contenido de la página, de forma asíncrona |
| Hacer clic tú mismo en las imágenes dentro del navegador | [Reconocimiento de imágenes de reCAPTCHA v2](https://docs.yescaptcha.com/es/tasks/recaptcha-classification.md), [Reconocimiento de imágenes de hCaptcha](https://docs.yescaptcha.com/es/tasks/hcaptcha-classification.md), [Reconocimiento de imágenes de FunCaptcha](https://docs.yescaptcha.com/es/tasks/funcaptcha-classification.md), [Reconocimiento de imágenes de AWS WAF / bCaptcha](https://docs.yescaptcha.com/es/tasks/aws-bcaptcha-classification.md) | Qué imágenes o qué posición debes pulsar, de forma síncrona |
| Leer los caracteres de una imagen | [Imagen a texto](https://docs.yescaptcha.com/es/tasks/image-to-text.md) | Texto, en su mayoría de forma síncrona |
Si no sabes qué captcha tienes, consulta [Identificar el tipo de captcha](https://docs.yescaptcha.com/es/guides/identify-captcha.md).
## Cómo se forman los nombres
- **`Proxyless`**: el captcha se carga desde nuestra red y no necesitas proxy. Los tipos sin `Proxyless` en el nombre (como `NoCaptchaTask` o `HCaptchaTask`) usan tu propio proxy y requieren los campos de proxy; son útiles cuando el sitio de destino comprueba la IP del visitante.
- **Sufijos como `M1`**: otra ruta para el mismo captcha, con los mismos parámetros y un precio distinto. Si una no logra una tasa de éxito suficiente, prueba la otra; también sirven como respaldo mutuo.
- **`Classification`**: reconocimiento de imágenes; devuelve dónde hacer clic, no un token.
- **`Enterprise`**: reCAPTCHA Enterprise.
## Notas
- El reconocimiento de imágenes de reCAPTCHA v2 se cobra según el tamaño de la imagen, y el de hCaptcha no cobra puntos cuando no encuentra el objetivo; consulta sus páginas.
- Los precios de esta página son la referencia. Solo se cobra la creación de tareas; las consultas no cobran puntos. Reglas de cobro: [Cobro y reembolso de puntos](https://docs.yescaptcha.com/es/getting-started/billing.md).
---
# reCAPTCHA v2
> Obtén tokens de reCAPTCHA v2 (casilla, invisible y Enterprise) con YesCaptcha: tipos de tarea y precios, parámetros de la solicitud, ejemplos en curl/Python/Node.js y formato del resultado.
Source: https://docs.yescaptcha.com/es/tasks/recaptcha-v2/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/tasks/recaptcha-v2/
Una tarea de reCAPTCHA v2 devuelve un token (`gRecaptchaResponse`) que envías al sitio de destino para pasar la verificación, sin necesidad de hacer clic en imágenes. El tipo más usado, `NoCaptchaTaskProxyless`, cuesta 15 puntos (≈ $2.25 / 1k) por tarea y es asíncrono: crea la tarea con `createTask` y luego llama a `getTaskResult` cada 5 segundos para obtener el resultado. Las tareas fallidas o que superan el tiempo de espera reciben un reembolso de puntos automático.
- POST `https://api.yescaptcha.com/createTask` (Endpoint global)
- POST `https://cn.yescaptcha.com/createTask` (Endpoint China)
El cuerpo de la solicitud es JSON y se autentica con tu `clientKey` (cópiala desde el Panel de [yescaptcha.com](https://yescaptcha.com/)). Consulta el resultado en el mismo endpoint en el que creaste la tarea.
## Cuándo usarlo
- La página muestra la casilla “No soy un robot” (I’m not a robot): versión con casilla.
- No hay casilla y el desafío con imágenes aparece solo después de pulsar el botón de envío: versión invisible. Añade `"isInvisible": true`.
- La página carga `recaptcha/enterprise.js`, o las URL de las solicitudes contienen `enterprise`: versión Enterprise. Usa un tipo con `Enterprise` en el nombre.
Si no estás seguro de cuál es, consulta [Identificar el tipo de captcha](https://docs.yescaptcha.com/es/guides/identify-captcha.md). Si los tokens no pasan con la frecuencia suficiente, prueba el [reconocimiento de imágenes de reCAPTCHA v2](https://docs.yescaptcha.com/es/tasks/recaptcha-classification.md): la API te indica qué imágenes pulsar y tú haces clic en ellas en el navegador.
## Tipos y precios
| Tipo de tarea | Precio | Modo | Notas |
| --- | --- | --- | --- |
| `NoCaptchaTaskProxyless` | $2.25 / 1k; 15 puntos/tarea · ¥15 / 1k | Asíncrono | |
| `RecaptchaV2TaskProxyless` | $3.00 / 1k; 20 puntos/tarea · ¥20 / 1k | Asíncrono | Mismos parámetros que NoCaptchaTaskProxyless en una ruta distinta; puedes usar cualquiera de los dos como respaldo |
| `NoCaptchaTask` | $2.25 / 1k; 15 puntos/tarea · ¥15 / 1k | Asíncrono | Proxy propio |
| `RecaptchaV2EnterpriseTaskProxyless` | $3.00 / 1k; 20 puntos/tarea · ¥20 / 1k | Asíncrono | |
| `RecaptchaV2EnterpriseTask` | $3.00 / 1k; 20 puntos/tarea · ¥20 / 1k | Asíncrono | Proxy propio |
Los precios en dólares son estimaciones con US$1 ≈ ¥6.67; las tareas se cobran en puntos.
- `NoCaptchaTaskProxyless` y `RecaptchaV2TaskProxyless` tienen los mismos parámetros y distinta ruta. Si uno no pasa con la frecuencia suficiente, prueba el otro.
- Los tipos sin `Proxyless` en el nombre (`NoCaptchaTask`, `RecaptchaV2EnterpriseTask`) cargan el captcha a través de tu propio proxy y requieren `proxyType`, `proxyAddress`, `proxyPort` y otros campos. Úsalos cuando el sitio de destino compruebe la IP del visitante.
## Parámetros de la solicitud
Campos del objeto `task` en `createTask`:
| Campo | Tipo | Obligatorio | Descripción |
| --- | --- | --- | --- |
| `type` | string | Sí | Tipo de tarea; consulta "Tipos de tarea y precios" en esta página |
| `websiteURL` | string | Sí | URL completa de la página que muestra el captcha. Usa el sitio donde ves el captcha, no el dominio del proveedor del captcha |
| `websiteKey` | string | Sí | La clave del sitio (sitekey), que se encuentra en el código fuente de la página o en las solicitudes de red; normalmente no cambia |
| `isInvisible` | boolean | No | Envía true para la variante invisible; en otro caso, omítelo |
| `proxyType` | string | Algunos tipos | Protocolo del proxy: `http`, `https`, `socks4` o `socks5` (Obligatorio para NoCaptchaTask, RecaptchaV2EnterpriseTask) |
| `proxyAddress` | string | Algunos tipos | Dirección IP o nombre de host del proxy. Las direcciones locales o privadas como 127.0.0.1 o 192.168.x.x no funcionan porque nuestros servidores no pueden acceder a ellas (Obligatorio para NoCaptchaTask, RecaptchaV2EnterpriseTask) |
| `proxyPort` | integer | Algunos tipos | Puerto del proxy (Obligatorio para NoCaptchaTask, RecaptchaV2EnterpriseTask) |
| `proxyLogin` | string | No | Usuario del proxy, si el proxy requiere autenticación (solo NoCaptchaTask, RecaptchaV2EnterpriseTask) |
| `proxyPassword` | string | No | Contraseña del proxy, si el proxy requiere autenticación (solo NoCaptchaTask, RecaptchaV2EnterpriseTask) |
| `userAgent` | string | No | User-Agent del navegador. Si el resultado contiene un `userAgent`, usa ese valor al enviar el token (solo NoCaptchaTask, RecaptchaV2EnterpriseTask) |
| `enterprisePayload` | object | No | Parámetros adicionales de la versión Enterprise, como el valor `s` de reCAPTCHA Enterprise: `{"s": "..."}`. Omítelo si la página no lo usa (solo RecaptchaV2EnterpriseTaskProxyless, RecaptchaV2EnterpriseTask) |
Para encontrar `websiteURL` y `websiteKey`, consulta [Encontrar los parámetros de reCAPTCHA](https://docs.yescaptcha.com/es/guides/find-recaptcha-parameters.md).
## Ejemplo de solicitud
Con la página de demostración oficial de Google:
POST https://api.yescaptcha.com/createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "NoCaptchaTaskProxyless",
"websiteURL": "https://www.google.com/recaptcha/api2/demo",
"websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"
}
}
```
Código completo que crea la tarea, consulta cada 5 segundos e imprime el token. Antes de ejecutarlo, guarda tu ClientKey en la variable de entorno `YESCAPTCHA_CLIENT_KEY`:
**curl**
```bash
curl -s https://api.yescaptcha.com/createTask \
-H 'Content-Type: application/json' \
-d '{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "NoCaptchaTaskProxyless",
"websiteURL": "https://www.google.com/recaptcha/api2/demo",
"websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"
}
}'
# Returns {"errorId":0,"taskId":"..."}; then poll every 5 seconds:
curl -s https://api.yescaptcha.com/getTaskResult \
-H 'Content-Type: application/json' \
-d '{"clientKey": "YOUR_CLIENT_KEY", "taskId": "TASK_ID"}'
```
**Python**
solve.py
```python
import os
import time
import requests
API = "https://api.yescaptcha.com"
CLIENT_KEY = os.environ["YESCAPTCHA_CLIENT_KEY"] # Read the clientKey from an environment variable
def call(method, payload):
r = requests.post(f"{API}/{method}", json={"clientKey": CLIENT_KEY, **payload}, timeout=30)
data = r.json()
if data.get("errorId"):
raise RuntimeError(f"{data.get('errorCode')}: {data.get('errorDescription')}")
return data
def solve(task):
task_id = call("createTask", {"task": task})["taskId"]
for _ in range(36): # Poll every 5 seconds, for up to about 3 minutes
time.sleep(5)
result = call("getTaskResult", {"taskId": task_id})
if result.get("status") == "ready":
return result["solution"]
raise TimeoutError(task_id)
solution = solve({
"type": "NoCaptchaTaskProxyless",
"websiteURL": "https://www.google.com/recaptcha/api2/demo",
"websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
})
print(solution["gRecaptchaResponse"])
```
**Node.js**
solve.mjs
```js
const API = 'https://api.yescaptcha.com';
const CLIENT_KEY = process.env.YESCAPTCHA_CLIENT_KEY; // Read the clientKey from an environment variable
async function call(method, payload) {
const res = await fetch(`${API}/${method}`, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ clientKey: CLIENT_KEY, ...payload }),
});
const data = await res.json();
if (data.errorId) throw new Error(`${data.errorCode}: ${data.errorDescription}`);
return data;
}
async function solve(task) {
const { taskId } = await call('createTask', { task });
for (let i = 0; i < 36; i++) { // Poll every 5 seconds, for up to about 3 minutes
await new Promise((r) => setTimeout(r, 5000));
const result = await call('getTaskResult', { taskId });
if (result.status === 'ready') return result.solution;
}
throw new Error(`timeout: ${taskId}`);
}
const solution = await solve({
type: "NoCaptchaTaskProxyless",
websiteURL: "https://www.google.com/recaptcha/api2/demo",
websiteKey: "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
});
console.log(solution.gRecaptchaResponse);
```
Para la versión Enterprise, si la página pasa un valor `s` a reCAPTCHA, colócalo en `enterprisePayload`:
POST https://api.yescaptcha.com/createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "RecaptchaV2EnterpriseTaskProxyless",
"websiteURL": "https://example.com/login",
"websiteKey": "SITE_KEY_OF_THE_PAGE",
"enterprisePayload": {
"s": "S_VALUE_FROM_THE_PAGE"
}
}
}
```
Con tu propio proxy:
POST https://api.yescaptcha.com/createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "NoCaptchaTask",
"websiteURL": "https://www.google.com/recaptcha/api2/demo",
"websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
"proxyType": "http",
"proxyAddress": "proxy.example.com",
"proxyPort": 8080,
"proxyLogin": "user",
"proxyPassword": "pass"
}
}
```
## Resultado
`createTask` devuelve un ID de tarea:
```json
{
"errorId": 0,
"taskId": "61138bb6-19fb-11ec-a9c8-0242ac110006"
}
```
Úsalo para llamar a `getTaskResult`. Mientras la tarea sigue en proceso, recibes `{"errorId": 0, "status": "processing"}`; consulta de nuevo 5 segundos después. Cuando termina, devuelve:
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"gRecaptchaResponse": "03AGdBq25SxXT-pmSeBXjzScW-EiocHwwpwqtk1QXlJnGnU..."
}
}
```
| Campo | Tipo | Descripción |
| --- | --- | --- |
| `gRecaptchaResponse` | string | El token que debes enviar al sitio de destino. De un solo uso, válido durante unos 120 segundos; úsalo en un plazo de 60 segundos |
Una tarea se procesa durante un máximo de unos 110 segundos; pasado ese tiempo devuelve `ERROR_TASK_TIMEOUT` y se reembolsan los puntos. Cuando hay un error, `errorId` es 1; gestiónalo según `errorCode`, como se describe en [Códigos de error](https://docs.yescaptcha.com/es/api/errors.md). Para saber cómo enviar el token, consulta [Completar reCAPTCHA con un token](https://docs.yescaptcha.com/es/guides/submit-recaptcha-token.md).
> **Consejo:** El token es de un solo uso y es válido durante unos 120 segundos; envíalo en los 60 segundos posteriores a recibirlo.
## Preguntas frecuentes
### ¿Por qué los tokens de un mismo sitio a veces pasan y a veces no?
Lo decide el sitio de destino. Puntúa cada verificación y aplica un umbral que puede cambiar en cualquier momento, por lo que la tasa de éxito varía según el sitio y no todos los tokens pasan. Puedes comparar con otro tipo de tarea del mismo captcha o cambiar al [reconocimiento de imágenes](https://docs.yescaptcha.com/es/tasks/recaptcha-classification.md).
### ¿Cuánto tiempo es válido un token?
Es de un solo uso y es válido durante unos 120 segundos. Envíalo en los 60 segundos posteriores a recibirlo. Google establece este límite.
### ¿Se cobran puntos si falla el reconocimiento?
No. Las tareas que devuelven `ERROR_CAPTCHA_UNSOLVABLE` o superan el tiempo de espera reciben un reembolso de puntos automático. Consulta [Facturación y reembolsos](https://docs.yescaptcha.com/es/getting-started/billing.md).
## Guías relacionadas
- [Identificar el tipo de captcha](https://docs.yescaptcha.com/es/guides/identify-captcha.md)
- [Encontrar los parámetros de reCAPTCHA](https://docs.yescaptcha.com/es/guides/find-recaptcha-parameters.md)
- [Completar reCAPTCHA con un token](https://docs.yescaptcha.com/es/guides/submit-recaptcha-token.md)
- [Clics de reconocimiento de imágenes de reCAPTCHA v2 con Selenium](https://docs.yescaptcha.com/es/guides/recaptcha-click-selenium.md)
---
# reCAPTCHA v3
> Obtén tokens de reCAPTCHA v3 (incluida la versión Enterprise) con YesCaptcha: cómo rellenar pageAction, los tipos con puntuación fija de 0.7 y 0.9, tipos de tarea y precios, parámetros, ejemplos y resultado.
Source: https://docs.yescaptcha.com/es/tasks/recaptcha-v3/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/tasks/recaptcha-v3/
reCAPTCHA v3 no tiene casilla de verificación ni imágenes: la página puntúa a los visitantes en segundo plano. YesCaptcha devuelve un token (`gRecaptchaResponse`) que envías al sitio de destino. `RecaptchaV3TaskProxyless` cuesta 20 puntos (≈ $3.00 / 1k) por tarea y es asíncrono: primero `createTask` y después `getTaskResult` cada 5 segundos. Si la tarea falla o agota el tiempo, los puntos se reembolsan automáticamente.
- POST `https://api.yescaptcha.com/createTask` (Endpoint global)
- POST `https://cn.yescaptcha.com/createTask` (Endpoint China)
El cuerpo de la solicitud es JSON y se autentica con `clientKey`. Consulta el resultado en el mismo endpoint en el que creaste la tarea.
## Cuándo usarlo
- El código fuente de la página contiene `grecaptcha.execute(...)` o carga `recaptcha/api.js?render=SITE_KEY`: reCAPTCHA v3 estándar.
- Llama a `grecaptcha.enterprise.execute(...)` o carga `recaptcha/enterprise.js`: reCAPTCHA v3 Enterprise. Usa `RecaptchaV3EnterpriseTask` o `RecaptchaV3EnterpriseTaskM1`.
Para saber cómo distinguirlos, consulta [Identificar el tipo de captcha](https://docs.yescaptcha.com/es/guides/identify-captcha.md).
## Tipos de tarea y precios
| Tipo de tarea | Precio | Modo | Notas |
| --- | --- | --- | --- |
| `RecaptchaV3TaskProxyless` | $3.00 / 1k; 20 puntos/tarea · ¥20 / 1k | Asíncrono | |
| `RecaptchaV3TaskProxylessM1` | $3.75 / 1k; 25 puntos/tarea · ¥25 / 1k | Asíncrono | |
| `RecaptchaV3TaskProxylessM1S7` | $4.50 / 1k; 30 puntos/tarea · ¥30 / 1k | Asíncrono | Solicita una puntuación de 0.7; no necesita parámetros adicionales |
| `RecaptchaV3TaskProxylessM1S9` | $5.25 / 1k; 35 puntos/tarea · ¥35 / 1k | Asíncrono | Solicita una puntuación de 0.9; no necesita parámetros adicionales |
| `RecaptchaV3EnterpriseTask` | $3.00 / 1k; 20 puntos/tarea · ¥20 / 1k | Asíncrono | |
| `RecaptchaV3EnterpriseTaskM1` | $3.75 / 1k; 25 puntos/tarea · ¥25 / 1k | Asíncrono | |
Los precios en dólares son estimaciones con US$1 ≈ ¥6.67; las tareas se cobran en puntos.
- `RecaptchaV3TaskProxyless` y `RecaptchaV3TaskProxylessM1` tienen los mismos parámetros pero usan rutas distintas; puedes usar uno como respaldo del otro.
- Si el sitio de destino exige una puntuación alta, usa `RecaptchaV3TaskProxylessM1S7` (0.7) o `RecaptchaV3TaskProxylessM1S9` (0.9); no necesitan parámetros adicionales.
## Parámetros de la solicitud
| Campo | Tipo | Obligatorio | Descripción |
| --- | --- | --- | --- |
| `type` | string | Sí | Tipo de tarea; consulta "Tipos de tarea y precios" en esta página |
| `websiteURL` | string | Sí | URL completa de la página que muestra el captcha. Usa el sitio donde ves el captcha, no el dominio del proveedor del captcha |
| `websiteKey` | string | Sí | La clave del sitio (sitekey), que se encuentra en el código fuente de la página o en las solicitudes de red; normalmente no cambia |
| `pageAction` | string | No | La acción de reCAPTCHA v3; debe coincidir con el valor que la página pasa a `grecaptcha.execute`, o el token podría ser rechazado |
`pageAction` debe coincidir con el `action` que la página pasa a `grecaptcha.execute(SITE_KEY, {action: '...'})`; si no, el sitio puede rechazar el token. Cómo encontrarlo: [Encontrar los parámetros de reCAPTCHA](https://docs.yescaptcha.com/es/guides/find-recaptcha-parameters.md).
## Ejemplo de solicitud
POST https://api.yescaptcha.com/createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "RecaptchaV3TaskProxyless",
"websiteURL": "https://example.com/login",
"websiteKey": "SITE_KEY_OF_THE_PAGE",
"pageAction": "login"
}
}
```
**curl**
```bash
curl -s https://api.yescaptcha.com/createTask \
-H 'Content-Type: application/json' \
-d '{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "RecaptchaV3TaskProxyless",
"websiteURL": "https://example.com/login",
"websiteKey": "SITE_KEY_OF_THE_PAGE",
"pageAction": "login"
}
}'
# Returns {"errorId":0,"taskId":"..."}; then poll every 5 seconds:
curl -s https://api.yescaptcha.com/getTaskResult \
-H 'Content-Type: application/json' \
-d '{"clientKey": "YOUR_CLIENT_KEY", "taskId": "TASK_ID"}'
```
**Python**
solve.py
```python
import os
import time
import requests
API = "https://api.yescaptcha.com"
CLIENT_KEY = os.environ["YESCAPTCHA_CLIENT_KEY"] # Read the clientKey from an environment variable
def call(method, payload):
r = requests.post(f"{API}/{method}", json={"clientKey": CLIENT_KEY, **payload}, timeout=30)
data = r.json()
if data.get("errorId"):
raise RuntimeError(f"{data.get('errorCode')}: {data.get('errorDescription')}")
return data
def solve(task):
task_id = call("createTask", {"task": task})["taskId"]
for _ in range(36): # Poll every 5 seconds, for up to about 3 minutes
time.sleep(5)
result = call("getTaskResult", {"taskId": task_id})
if result.get("status") == "ready":
return result["solution"]
raise TimeoutError(task_id)
solution = solve({
"type": "RecaptchaV3TaskProxyless",
"websiteURL": "https://example.com/login",
"websiteKey": "SITE_KEY_OF_THE_PAGE",
"pageAction": "login",
})
print(solution["gRecaptchaResponse"])
```
**Node.js**
solve.mjs
```js
const API = 'https://api.yescaptcha.com';
const CLIENT_KEY = process.env.YESCAPTCHA_CLIENT_KEY; // Read the clientKey from an environment variable
async function call(method, payload) {
const res = await fetch(`${API}/${method}`, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ clientKey: CLIENT_KEY, ...payload }),
});
const data = await res.json();
if (data.errorId) throw new Error(`${data.errorCode}: ${data.errorDescription}`);
return data;
}
async function solve(task) {
const { taskId } = await call('createTask', { task });
for (let i = 0; i < 36; i++) { // Poll every 5 seconds, for up to about 3 minutes
await new Promise((r) => setTimeout(r, 5000));
const result = await call('getTaskResult', { taskId });
if (result.status === 'ready') return result.solution;
}
throw new Error(`timeout: ${taskId}`);
}
const solution = await solve({
type: "RecaptchaV3TaskProxyless",
websiteURL: "https://example.com/login",
websiteKey: "SITE_KEY_OF_THE_PAGE",
pageAction: "login",
});
console.log(solution.gRecaptchaResponse);
```
Sustituye `websiteURL`, `websiteKey` y `pageAction` por los valores del sitio de destino.
## Resultado
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"gRecaptchaResponse": "03AGdBq25SxXT-pmSeBXjzScW-EiocHwwpwqtk1QXlJnGnU..."
}
}
```
| Campo | Tipo | Descripción |
| --- | --- | --- |
| `gRecaptchaResponse` | string | El token que debes enviar al sitio de destino. De un solo uso, válido durante unos 120 segundos; úsalo en un plazo de 60 segundos |
Mientras la tarea se procesa, recibes `{"errorId": 0, "status": "processing"}`; vuelve a consultar 5 segundos después. Si hay un error, trátalo según `errorCode`, como se explica en [Códigos de error](https://docs.yescaptcha.com/es/api/errors.md). Para saber cómo enviar el token, consulta [Completar reCAPTCHA con un token](https://docs.yescaptcha.com/es/guides/submit-recaptcha-token.md).
## Preguntas frecuentes
### ¿Por qué el sitio rechaza algunos tokens?
En v3 es el sitio de destino quien decide según la puntuación, y puede cambiar su umbral en cualquier momento, así que no todos los tokens pasan. Comprueba que `pageAction` sea correcto; si el sitio exige una puntuación alta, prueba `M1S7` o `M1S9`; también puedes comparar con otros tipos similares.
### ¿Cómo relleno la versión Enterprise de v3?
Igual que la versión estándar: `websiteURL`, `websiteKey` y `pageAction`, con el tipo `RecaptchaV3EnterpriseTask` o `RecaptchaV3EnterpriseTaskM1`.
### ¿Cuánto tiempo es válido un token?
Es de un solo uso y es válido unos 120 segundos. Te recomendamos enviarlo en menos de 60 segundos.
## Guías relacionadas
- [Identificar el tipo de captcha](https://docs.yescaptcha.com/es/guides/identify-captcha.md)
- [Encontrar los parámetros de reCAPTCHA](https://docs.yescaptcha.com/es/guides/find-recaptcha-parameters.md) (incluye cómo encontrar `pageAction`)
- [Completar reCAPTCHA con un token](https://docs.yescaptcha.com/es/guides/submit-recaptcha-token.md)
---
# hCaptcha
> Obtén tokens de hCaptcha con YesCaptcha: HCaptchaTaskProxyless, HCaptchaTaskProxylessM1 y HCaptchaTask con tu propio proxy, cómo rellenar userAgent y rqdata, y cómo usar el respKey devuelto.
Source: https://docs.yescaptcha.com/es/tasks/hcaptcha/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/tasks/hcaptcha/
Una tarea de hCaptcha devuelve un token (`gRecaptchaResponse`). Envíalo al sitio de destino junto con el `userAgent` devuelto (y el `respKey`, cuando exista) para superar la verificación. `HCaptchaTaskProxyless` cuesta 30 puntos (≈ $4.50 / 1k) por tarea y `HCaptchaTask` (con tu propio proxy) cuesta 15 puntos (≈ $2.25 / 1k) por tarea. Ambos son asíncronos: primero `createTask` y después `getTaskResult` cada 5 segundos. Si el reconocimiento falla o se agota el tiempo, los puntos se reembolsan automáticamente.
- POST `https://api.yescaptcha.com/createTask` (Endpoint global)
- POST `https://cn.yescaptcha.com/createTask` (Endpoint China)
El cuerpo de la solicitud es JSON y se autentica con tu `clientKey`. Consulta el resultado en el mismo endpoint en el que creaste la tarea.
## Cuándo usarlo
La página muestra la casilla “Soy humano” de hCaptcha o aparece un desafío de imágenes de hCaptcha. Si quieres obtener un token y enviarlo directamente, usa los tipos de esta página; si prefieres hacer clic en las imágenes tú mismo en el navegador, usa [reconocimiento de imágenes de hCaptcha](https://docs.yescaptcha.com/es/tasks/hcaptcha-classification.md).
> **Nota:** La tasa de éxito de hCaptcha varía mucho entre sitios; te recomendamos probar primero con un lote pequeño.
## Tipos y precios
| Tipo de tarea | Precio | Modo | Notas |
| --- | --- | --- | --- |
| `HCaptchaTaskProxyless` | $4.50 / 1k; 30 puntos/tarea · ¥30 / 1k | Asíncrono | |
| `HCaptchaTaskProxylessM1` | $4.50 / 1k; 30 puntos/tarea · ¥30 / 1k | Asíncrono | Mismos parámetros que HCaptchaTaskProxyless en una ruta distinta; puedes usar cualquiera de los dos como respaldo |
| `HCaptchaTask` | $2.25 / 1k; 15 puntos/tarea · ¥15 / 1k | Asíncrono | Proxy propio |
Los precios en dólares son estimaciones con US$1 ≈ ¥6.67; las tareas se cobran en puntos.
- `HCaptchaTaskProxyless` y `HCaptchaTaskProxylessM1` tienen los mismos parámetros pero usan rutas distintas; puedes usar uno como respaldo del otro.
- `HCaptchaTask` carga el captcha con tu propio proxy y requiere los campos de proxy; úsalo cuando el sitio de destino compruebe la IP de acceso.
## Parámetros de la solicitud
| Campo | Tipo | Obligatorio | Descripción |
| --- | --- | --- | --- |
| `type` | string | Sí | Tipo de tarea; consulta "Tipos de tarea y precios" en esta página |
| `websiteURL` | string | Sí | URL completa de la página que muestra el captcha. Usa el sitio donde ves el captcha, no el dominio del proveedor del captcha |
| `websiteKey` | string | Sí | La clave del sitio (sitekey) de hCaptcha, normalmente un UUID |
| `userAgent` | string | No | User-Agent del navegador. Recomendado, pero solo se acepta el valor devuelto por `GET https://api.yescaptcha.com/useragent`; envía el token con el `userAgent` del resultado |
| `isInvisible` | boolean | No | Envía true para la variante invisible; en otro caso, omítelo |
| `rqdata` | string | No | rqdata de hCaptcha Enterprise; algunos sitios lo requieren y normalmente se encuentra en la solicitud que carga el captcha |
| `proxyType` | string | Algunos tipos | Protocolo del proxy: `http`, `https`, `socks4` o `socks5` (Obligatorio para HCaptchaTask) |
| `proxyAddress` | string | Algunos tipos | Dirección IP o nombre de host del proxy. Las direcciones locales o privadas como 127.0.0.1 o 192.168.x.x no funcionan porque nuestros servidores no pueden acceder a ellas (Obligatorio para HCaptchaTask) |
| `proxyPort` | integer | Algunos tipos | Puerto del proxy (Obligatorio para HCaptchaTask) |
| `proxyLogin` | string | No | Usuario del proxy, si el proxy requiere autenticación (solo HCaptchaTask) |
| `proxyPassword` | string | No | Contraseña del proxy, si el proxy requiere autenticación (solo HCaptchaTask) |
- `websiteURL` es la página donde aparece el captcha, **no** hcaptcha.com.
- `userAgent` es recomendable, y solo se acepta el valor devuelto por [/useragent](https://docs.yescaptcha.com/es/api/useragent.md).
- `rqdata`: lo exigen los sitios con hCaptcha Enterprise (por ejemplo, algunos sitios sociales y de chat) y normalmente se encuentra en la solicitud que carga el captcha. En sitios normales, no lo envíes.
Para saber cómo encontrar los parámetros, consulta [Cómo encontrar los parámetros de hCaptcha](https://docs.yescaptcha.com/es/guides/find-hcaptcha-parameters.md).
## Ejemplo de solicitud
POST https://api.yescaptcha.com/createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "HCaptchaTaskProxyless",
"websiteURL": "https://accounts.hcaptcha.com/demo",
"websiteKey": "a5f74b19-9e45-40e0-b45d-47ff91b7a6c2"
}
}
```
**curl**
```bash
curl -s https://api.yescaptcha.com/createTask \
-H 'Content-Type: application/json' \
-d '{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "HCaptchaTaskProxyless",
"websiteURL": "https://accounts.hcaptcha.com/demo",
"websiteKey": "a5f74b19-9e45-40e0-b45d-47ff91b7a6c2"
}
}'
# Returns {"errorId":0,"taskId":"..."}; then poll every 5 seconds:
curl -s https://api.yescaptcha.com/getTaskResult \
-H 'Content-Type: application/json' \
-d '{"clientKey": "YOUR_CLIENT_KEY", "taskId": "TASK_ID"}'
```
**Python**
solve.py
```python
import os
import time
import requests
API = "https://api.yescaptcha.com"
CLIENT_KEY = os.environ["YESCAPTCHA_CLIENT_KEY"] # Read the clientKey from an environment variable
def call(method, payload):
r = requests.post(f"{API}/{method}", json={"clientKey": CLIENT_KEY, **payload}, timeout=30)
data = r.json()
if data.get("errorId"):
raise RuntimeError(f"{data.get('errorCode')}: {data.get('errorDescription')}")
return data
def solve(task):
task_id = call("createTask", {"task": task})["taskId"]
for _ in range(36): # Poll every 5 seconds, for up to about 3 minutes
time.sleep(5)
result = call("getTaskResult", {"taskId": task_id})
if result.get("status") == "ready":
return result["solution"]
raise TimeoutError(task_id)
solution = solve({
"type": "HCaptchaTaskProxyless",
"websiteURL": "https://accounts.hcaptcha.com/demo",
"websiteKey": "a5f74b19-9e45-40e0-b45d-47ff91b7a6c2",
})
print(solution["gRecaptchaResponse"])
```
**Node.js**
solve.mjs
```js
const API = 'https://api.yescaptcha.com';
const CLIENT_KEY = process.env.YESCAPTCHA_CLIENT_KEY; // Read the clientKey from an environment variable
async function call(method, payload) {
const res = await fetch(`${API}/${method}`, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ clientKey: CLIENT_KEY, ...payload }),
});
const data = await res.json();
if (data.errorId) throw new Error(`${data.errorCode}: ${data.errorDescription}`);
return data;
}
async function solve(task) {
const { taskId } = await call('createTask', { task });
for (let i = 0; i < 36; i++) { // Poll every 5 seconds, for up to about 3 minutes
await new Promise((r) => setTimeout(r, 5000));
const result = await call('getTaskResult', { taskId });
if (result.status === 'ready') return result.solution;
}
throw new Error(`timeout: ${taskId}`);
}
const solution = await solve({
type: "HCaptchaTaskProxyless",
websiteURL: "https://accounts.hcaptcha.com/demo",
websiteKey: "a5f74b19-9e45-40e0-b45d-47ff91b7a6c2",
});
console.log(solution.gRecaptchaResponse);
```
Con tu propio proxy:
POST https://api.yescaptcha.com/createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "HCaptchaTask",
"websiteURL": "https://accounts.hcaptcha.com/demo",
"websiteKey": "a5f74b19-9e45-40e0-b45d-47ff91b7a6c2",
"proxyType": "http",
"proxyAddress": "proxy.example.com",
"proxyPort": 8080,
"proxyLogin": "user",
"proxyPassword": "pass"
}
}
```
## Resultado
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"gRecaptchaResponse": "P1_eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9...",
"userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/155.0.0.0 Safari/537.36",
"respKey": "E0_eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9..."
}
}
```
| Campo | Tipo | Descripción |
| --- | --- | --- |
| `gRecaptchaResponse` | string | El token que debes enviar al sitio de destino. De un solo uso, válido durante unos 120 segundos; úsalo en un plazo de 60 segundos |
| `userAgent` | string | El User-Agent usado para obtener el token. Usa este valor al enviar el token, aunque sea distinto del que enviaste |
| `respKey` | string | Un valor que algunos sitios exigen junto con el token; envíalo si está presente |
Al enviar:
1. Coloca el token en el campo `h-captcha-response` de la página (y en `g-recaptcha-response`, si existe), o en el campo que exija la API del sitio de destino.
2. Al enviar la solicitud, usa como User-Agent el `userAgent` devuelto.
3. Si se devolvió un `respKey`, envíalo también según lo que pida el sitio.
Mientras la tarea está en proceso se devuelve `{"errorId": 0, "status": "processing"}`; consulta de nuevo 5 segundos después. Si hay un error, trátalo según el `errorCode`; consulta [Códigos de error](https://docs.yescaptcha.com/es/api/errors.md).
## Preguntas frecuentes
### ¿Por qué la tasa de éxito no es estable?
hCaptcha decide según la configuración del sitio, la IP de acceso y el entorno del navegador, por lo que la tasa de éxito varía de un sitio a otro. Comprueba que uses el `userAgent` devuelto; en sitios sensibles a la IP, usa `HCaptchaTask` con tu propio proxy y envía también el formulario a través del mismo proxy; también puedes comparar con `HCaptchaTaskProxylessM1`.
### ¿Cuánto tiempo es válido el token?
Es de un solo uso y es válido durante unos 120 segundos. Te recomendamos enviarlo lo antes posible.
## Tutoriales relacionados
- [Cómo encontrar los parámetros de hCaptcha](https://docs.yescaptcha.com/es/guides/find-hcaptcha-parameters.md)
- [Clics de reconocimiento de imágenes de hCaptcha con Selenium](https://docs.yescaptcha.com/es/guides/hcaptcha-click-selenium.md)
---
# Cloudflare Turnstile
> Obtén tokens de Cloudflare Turnstile con YesCaptcha: TurnstileTaskProxyless, TurnstileTaskProxylessM1 y TurnstileTask con tu propio proxy, parámetros, ejemplos y formato del resultado; y en qué se diferencia de la página de verificación de Cloudflare.
Source: https://docs.yescaptcha.com/es/tasks/turnstile/ · Last verified: 2026-10-21
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/tasks/turnstile/
Una tarea de Cloudflare Turnstile devuelve un token (`token`) que envías al sitio de destino para superar la verificación. `TurnstileTaskProxyless` cuesta 25 puntos (≈ $3.75 / 1k) por tarea y es asíncrona: primero `createTask` y después `getTaskResult` cada 5 segundos. Si la tarea falla o expira, se hace un reembolso de puntos automático.
- POST `https://api.yescaptcha.com/createTask` (Endpoint global)
- POST `https://cn.yescaptcha.com/createTask` (Endpoint China)
El cuerpo de la solicitud es JSON y se autentica con `clientKey`. Consulta el resultado en el mismo endpoint en el que creaste la tarea.
## Cuándo usarlo
Un formulario de la página incluye el cuadro de verificación de Cloudflare (“Confirma que eres humano”) y la página carga el script de `challenges.cloudflare.com/turnstile`.
Si Cloudflare bloquea toda la página y muestra “Un momento…” o “Verificando su navegador”, se trata de la página de verificación de Cloudflare, no de Turnstile; usa [página de verificación de Cloudflare](https://docs.yescaptcha.com/es/tasks/cloudflare-challenge.md). Consulta las diferencias en [Identificar el tipo de captcha](https://docs.yescaptcha.com/es/guides/identify-captcha.md).
## Tipos de tarea y precios
| Tipo de tarea | Precio | Modo | Notas |
| --- | --- | --- | --- |
| `TurnstileTaskProxyless` | $3.75 / 1k; 25 puntos/tarea · ¥25 / 1k | Asíncrono | |
| `TurnstileTaskProxylessM1` | $4.50 / 1k; 30 puntos/tarea · ¥30 / 1k | Asíncrono | |
| `TurnstileTask` | $3.75 / 1k; 25 puntos/tarea · ¥25 / 1k | Asíncrono | Proxy propio |
Los precios en dólares son estimaciones con US$1 ≈ ¥6.67; las tareas se cobran en puntos.
- `TurnstileTaskProxyless` y `TurnstileTaskProxylessM1` tienen los mismos parámetros y distinta ruta; puedes usar uno como respaldo del otro.
- `TurnstileTask` carga el captcha con tu propio proxy y requiere los campos de proxy.
## Parámetros de la solicitud
| Campo | Tipo | Obligatorio | Descripción |
| --- | --- | --- | --- |
| `type` | string | Sí | Tipo de tarea; consulta "Tipos de tarea y precios" en esta página |
| `websiteURL` | string | Sí | URL completa de la página que muestra el captcha. Usa el sitio donde ves el captcha, no el dominio del proveedor del captcha |
| `websiteKey` | string | Sí | La clave del sitio (sitekey) de Turnstile, normalmente empieza por 0x |
| `pageAction` | string | No | La `action` que la página pasa a Turnstile (una opción de `turnstile.render`, o `data-action` en el elemento del widget), p. ej. `login`. No es necesaria en la mayoría de los casos; agrégala solo cuando las tareas sigan fallando |
| `data` | string | No | El `cData` que la página pasa a Turnstile (una opción de `turnstile.render`, o `data-cdata` en el elemento del widget), p. ej. `c0bd4b36-7419-4e18-83c6-378699f2a9a2`. No es necesario en la mayoría de los casos; agrégalo solo cuando las tareas sigan fallando |
| `proxyType` | string | Algunos tipos | Protocolo del proxy: `http`, `https`, `socks4` o `socks5` (Obligatorio para TurnstileTask) |
| `proxyAddress` | string | Algunos tipos | Dirección IP o nombre de host del proxy. Las direcciones locales o privadas como 127.0.0.1 o 192.168.x.x no funcionan porque nuestros servidores no pueden acceder a ellas (Obligatorio para TurnstileTask) |
| `proxyPort` | integer | Algunos tipos | Puerto del proxy (Obligatorio para TurnstileTask) |
| `proxyLogin` | string | No | Usuario del proxy, si el proxy requiere autenticación (solo TurnstileTask) |
| `proxyPassword` | string | No | Contraseña del proxy, si el proxy requiere autenticación (solo TurnstileTask) |
| `userAgent` | string | No | User-Agent del navegador. Si el resultado contiene un `userAgent`, usa ese valor al enviar el token (solo TurnstileTask) |
`websiteKey` suele empezar por `0x`. Para saber cómo encontrarlo, consulta [Encontrar los parámetros de Turnstile](https://docs.yescaptcha.com/es/guides/find-turnstile-parameters.md).
### Si la tarea no pasa: pageAction y data
En la gran mayoría de los casos basta con `websiteURL` y `websiteKey`, y no necesitas estos dos parámetros. Si estás seguro de que `websiteURL` y `websiteKey` son correctos y la tarea sigue sin pasar, revisa si la página pasa `action` y `cData` a Turnstile (opciones de `turnstile.render`, o `data-action` y `data-cdata` en el elemento del cuadro de verificación). Si los pasa, envíalos tal cual:
- `pageAction`: el `action` de la página, por ejemplo `login`
- `data`: el `cData` de la página, por ejemplo `c0bd4b36-7419-4e18-83c6-378699f2a9a2`
POST https://api.yescaptcha.com/createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "TurnstileTaskProxyless",
"websiteURL": "https://example.com/login",
"websiteKey": "0x4AAAAAAA_SITE_KEY",
"pageAction": "login",
"data": "c0bd4b36-7419-4e18-83c6-378699f2a9a2"
}
}
```
## Ejemplo de solicitud
POST https://api.yescaptcha.com/createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "TurnstileTaskProxyless",
"websiteURL": "https://example.com/login",
"websiteKey": "0x4AAAAAAA_SITE_KEY"
}
}
```
**curl**
```bash
curl -s https://api.yescaptcha.com/createTask \
-H 'Content-Type: application/json' \
-d '{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "TurnstileTaskProxyless",
"websiteURL": "https://example.com/login",
"websiteKey": "0x4AAAAAAA_SITE_KEY"
}
}'
# Returns {"errorId":0,"taskId":"..."}; then poll every 5 seconds:
curl -s https://api.yescaptcha.com/getTaskResult \
-H 'Content-Type: application/json' \
-d '{"clientKey": "YOUR_CLIENT_KEY", "taskId": "TASK_ID"}'
```
**Python**
solve.py
```python
import os
import time
import requests
API = "https://api.yescaptcha.com"
CLIENT_KEY = os.environ["YESCAPTCHA_CLIENT_KEY"] # Read the clientKey from an environment variable
def call(method, payload):
r = requests.post(f"{API}/{method}", json={"clientKey": CLIENT_KEY, **payload}, timeout=30)
data = r.json()
if data.get("errorId"):
raise RuntimeError(f"{data.get('errorCode')}: {data.get('errorDescription')}")
return data
def solve(task):
task_id = call("createTask", {"task": task})["taskId"]
for _ in range(36): # Poll every 5 seconds, for up to about 3 minutes
time.sleep(5)
result = call("getTaskResult", {"taskId": task_id})
if result.get("status") == "ready":
return result["solution"]
raise TimeoutError(task_id)
solution = solve({
"type": "TurnstileTaskProxyless",
"websiteURL": "https://example.com/login",
"websiteKey": "0x4AAAAAAA_SITE_KEY",
})
print(solution["token"])
```
**Node.js**
solve.mjs
```js
const API = 'https://api.yescaptcha.com';
const CLIENT_KEY = process.env.YESCAPTCHA_CLIENT_KEY; // Read the clientKey from an environment variable
async function call(method, payload) {
const res = await fetch(`${API}/${method}`, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ clientKey: CLIENT_KEY, ...payload }),
});
const data = await res.json();
if (data.errorId) throw new Error(`${data.errorCode}: ${data.errorDescription}`);
return data;
}
async function solve(task) {
const { taskId } = await call('createTask', { task });
for (let i = 0; i < 36; i++) { // Poll every 5 seconds, for up to about 3 minutes
await new Promise((r) => setTimeout(r, 5000));
const result = await call('getTaskResult', { taskId });
if (result.status === 'ready') return result.solution;
}
throw new Error(`timeout: ${taskId}`);
}
const solution = await solve({
type: "TurnstileTaskProxyless",
websiteURL: "https://example.com/login",
websiteKey: "0x4AAAAAAA_SITE_KEY",
});
console.log(solution.token);
```
Sustituye `websiteURL` y `websiteKey` por los valores del sitio de destino.
## Resultado
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"token": "0.ufq5RgSVZd11DPSX1brdrxnEs28KcVlKj2ORchqxSy2q9yAW6ciq3hriXDF4x...",
"userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/155.0.0.0 Safari/537.36"
}
}
```
| Campo | Tipo | Descripción |
| --- | --- | --- |
| `token` | string | El token que debes enviar al sitio de destino. De un solo uso; envíalo lo antes posible |
| `userAgent` | string | El User-Agent usado para obtener el token. Usa este valor al enviar el token, aunque sea distinto del que enviaste |
Coloca el `token` en el campo `cf-turnstile-response` de la página (o en el campo que exija la API del sitio de destino) y envíalo, usando como User-Agent el `userAgent` devuelto.
Mientras se procesa, la respuesta es `{"errorId": 0, "status": "processing"}`; vuelve a consultar 5 segundos después. Si hay un error, gestiónalo según `errorCode`; consulta [Códigos de error](https://docs.yescaptcha.com/es/api/errors.md).
## Preguntas frecuentes
### ¿Cuánto tiempo es válido el token?
Es de un solo uso. Te recomendamos enviarlo lo antes posible tras obtenerlo (los tokens de Turnstile suelen caducar en pocos minutos, según lo decide Cloudflare).
### Tras el envío, el sitio sigue sin aceptarlo
Comprueba que `websiteURL` sea la página donde aparece el cuadro de verificación, que `websiteKey` sea correcto y que en el envío uses el `userAgent` devuelto. Si la página pasa `action` y `cData`, envíalos como `pageAction` y `data`; consulta [Si la tarea no pasa](#si-la-tarea-no-pasa-pageaction-y-data) más arriba. Si el sitio también comprueba la IP, usa `TurnstileTask` y haz el envío a través del mismo proxy.
## Tutoriales relacionados
- [Identificar el tipo de captcha](https://docs.yescaptcha.com/es/guides/identify-captcha.md)
- [Encontrar los parámetros de Turnstile](https://docs.yescaptcha.com/es/guides/find-turnstile-parameters.md)
---
# Página de verificación de Cloudflare (5 segundos)
> Supera con YesCaptcha la página de comprobación "Un momento…" de Cloudflare y obtén cookies como cf_clearance, el User-Agent y el contenido de la página. Parámetros de CloudFlareTaskS2 y CloudFlareTaskS3, requisitos del proxy, resultados, cómo usarlos y errores comunes.
Source: https://docs.yescaptcha.com/es/tasks/cloudflare-challenge/ · Last verified: 2026-10-19
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/tasks/cloudflare-challenge/
La página de verificación de Cloudflare es la página de comprobación que bloquea todo el sitio y muestra “Un momento…” o “Comprobando tu navegador”. YesCaptcha abre la página con el proxy que le indiques, supera la comprobación y devuelve cookies como `cf_clearance`, el User-Agent que usó, los encabezados de la solicitud y de la respuesta, y el HTML de la página una vez superada. `CloudFlareTaskS2` cuesta 25 puntos (≈ $3.75 / 1k) por tarea y `CloudFlareTaskS3` cuesta 20 puntos (≈ $3.00 / 1k) por tarea; los dos tipos tienen los mismos parámetros, resultados y efectividad, y solo cambia el precio. Es asíncrono: una tarea suele tardar entre 6 y 35 segundos, con diferencias notables según el sitio. Si la resolución falla o se agota el tiempo, se hace un reembolso de puntos automático.
- POST `https://api.yescaptcha.com/createTask` (Endpoint global)
- POST `https://cn.yescaptcha.com/createTask` (Endpoint China)
## Cuándo usarlo
- El código fuente de la página contiene `__cf_chl_rt_tk` o `cdn-cgi/challenge-platform`, y el título es `Just a moment...` / “Un momento…”: es la página de verificación de Cloudflare. Las páginas de comprobación que piden marcar la casilla “Confirma que eres una persona” también se resuelven con esta página.
- Si solo hay un cuadro de verificación de Cloudflare incrustado en un formulario, es [Turnstile](https://docs.yescaptcha.com/es/tasks/turnstile.md) y no necesitas esta página.
- Si al hacer la solicitud con una librería como requests recibes un 403 con “Just a moment…” pero el navegador abre la página sin problema, lo más probable es que solo te bloqueen por la huella TLS. Usa una librería que imite la huella TLS de un navegador (como curl\_cffi) y podrás hacer la solicitud sin necesidad de superar la comprobación.
## Tipos y precios
| Tipo de tarea | Precio | Modo | Notas |
| --- | --- | --- | --- |
| `CloudFlareTaskS2` | $3.75 / 1k; 25 puntos/tarea · ¥25 / 1k | Asíncrono | Proxy propio |
| `CloudFlareTaskS3` | $3.00 / 1k; 20 puntos/tarea · ¥20 / 1k | Asíncrono | Proxy propio |
Los precios en dólares son estimaciones con US$1 ≈ ¥6.67; las tareas se cobran en puntos.
## Parámetros de la solicitud
| Campo | Tipo | Obligatorio | Descripción |
| --- | --- | --- | --- |
| `type` | string | Sí | Tipo de tarea; consulta "Tipos de tarea y precios" en esta página |
| `websiteURL` | string | Sí | URL completa de la página protegida por la verificación. Debe ser una URL pública que empiece por `http://` o `https://`; se rechazan las direcciones IP privadas y los nombres de host locales o internos como `localhost` |
| `proxy` | string | Sí | Proxy como una sola cadena: `http://user:pass@proxy.example.com:8080` (proxy HTTP, credenciales opcionales) o `socks5://proxy.example.com:1080` (sin credenciales). No se admiten proxies `https://` ni SOCKS5 con credenciales, y se rechazan las direcciones locales o privadas. Todas las solicitudes a la página de destino pasan por este proxy |
| `userAgent` | string | No | Normalmente omítelo. Solo se usa un User-Agent de Chrome de escritorio en Linux; cualquier otro (Windows, macOS, móvil, otros navegadores) se ignora. Usa siempre el `user_agent` del resultado en las solicitudes posteriores |
| `waitLoad` | boolean | No | Por defecto es false. Si es true, después de superar la verificación la tarea espera a que se estabilice la actividad de red de la página antes de devolver el resultado, así que `content` incluye más contenido cargado dinámicamente; tarda unos segundos más |
| `requiredCookies` | array | No | Nombres de las cookies que se deben obtener, como un arreglo de cadenas, p. ej. `["cf_clearance"]`. Si se envía, la tarea solo tiene éxito cuando se obtienen todas; de lo contrario devuelve `ERROR_CAPTCHA_UNSOLVABLE` y se reembolsan los puntos. Si se omite, la tarea igualmente intenta obtener `cf_clearance`, pero tiene éxito (y se cobran los puntos) con las otras cookies que haya obtenido, así que envíalo explícitamente si necesitas `cf_clearance` |
| `blockImage` | boolean | No | Si es true, no se cargan las imágenes de la página de destino (excepto las que necesita la propia verificación de Cloudflare), lo que ahorra tráfico del proxy |
| `postData` | object | No | Si se envía, se manda a `websiteURL` como un POST de formulario HTML normal (`application/x-www-form-urlencoded`): cada clave es un campo del formulario y los valores se envían como cadenas, p. ej. `{"name": "hi"}`. Debe ser un objeto |
### Requisitos del proxy
`proxy` es obligatorio, y todas las solicitudes para abrir la página de destino pasan por este proxy. `cf_clearance` está ligado a la IP de salida, así que después debes usar el mismo proxy para acceder al sitio de destino.
| Formato | ¿Compatible? |
| --- | --- |
| `http://user:pass@proxy.example.com:8080` | Sí: proxy http con usuario y contraseña |
| `http://proxy.example.com:8080` | Sí: proxy http sin usuario ni contraseña |
| `socks5://proxy.example.com:1080` | Sí: proxy socks5 sin usuario ni contraseña; `socks5h://` se trata como `socks5://` |
| `socks5://user:pass@proxy.example.com:1080` | No, devuelve `ERROR_PROXY_INCORRECT`; si necesitas usuario y contraseña, usa un proxy http |
| `https://proxy.example.com:443` u otros protocolos, o sin puerto | No, devuelve `ERROR_PROXY_INCORRECT` |
| Direcciones locales, de red interna o reservadas como `127.0.0.1`, `192.168.x.x`, `10.x.x.x`, o dominios que se resuelven a ellas | Se rechaza, devuelve `ERROR_PROXY_BANNED` |
> **Se comprueba al crear la tarea:** Si la URL o el proxy no son válidos, `createTask` devuelve el error de inmediato y no se cobran puntos. Si un mismo proxy no logra conectarse varias veces en poco tiempo, durante un tiempo las tareas creadas con él también devolverán directamente `ERROR_PROXY_BANNED`; cambia de proxy o inténtalo más tarde.
### User-Agent
Normalmente no envíes `userAgent`. Superamos la comprobación con Chrome de escritorio en Linux, así que solo se usa un User-Agent que también sea de Chrome de escritorio en Linux; cualquier otro (Windows, macOS, móvil u otros navegadores) se ignora: en las pruebas, Cloudflare no supera la comprobación cuando el entorno real del navegador no coincide con el User-Agent. En las solicitudes posteriores usa siempre el `user_agent` del resultado.
## Ejemplo de solicitud
POST https://api.yescaptcha.com/createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "CloudFlareTaskS3",
"websiteURL": "https://example.com/",
"proxy": "http://user:pass@proxy.example.com:8080",
"requiredCookies": ["cf_clearance"]
}
}
```
- Para usar `CloudFlareTaskS2`, cambia solo `type`; lo demás queda igual.
- Si envías `requiredCookies` con `["cf_clearance"]` y no se obtiene `cf_clearance`, la tarea falla y se reembolsan los puntos. Si no lo envías, una tarea que no obtiene `cf_clearance` pero sí otras cookies también se considera exitosa y se cobran los puntos.
- Para enviar un formulario, añade `postData`, por ejemplo `{"name": "hi"}`; se enviará a `websiteURL` como un formulario POST.
Tras crear la tarea, llama a `getTaskResult` cada 5 segundos; el flujo es igual que en las demás tareas asíncronas, consulta [getTaskResult](https://docs.yescaptcha.com/es/api/get-task-result.md).
## Resultado
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"user_agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/155.0.0.0 Safari/537.36",
"cookies": {
"cf_clearance": "Wq3vXk9...-1760860800-1.2.1.1-..."
},
"request_headers": {
"accept-language": "en-US,en;q=0.9",
"user-agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/155.0.0.0 Safari/537.36"
},
"headers": {
"content-type": "text/html; charset=UTF-8",
"server": "cloudflare"
},
"content": "..."
}
}
```
El valor de la cookie y los encabezados de arriba son ilustrativos; usa lo que devuelva la API.
| Campo | Tipo | Descripción |
| --- | --- | --- |
| `cookies` | object | Todas las cookies del navegador después de pasar la verificación (objeto de nombre a valor), normalmente incluye `cf_clearance`; si envías `requiredCookies`, se incluyen todas ellas. Úsalas junto con el `user_agent` devuelto y el proxy que indicaste |
| `user_agent` | string | El User-Agent que el navegador usó realmente para pasar la verificación (Chrome de escritorio en Linux). `cf_clearance` está vinculado a él, así que úsalo en todas las solicitudes posteriores |
| `request_headers` | object | Encabezados de solicitud que el navegador envió en su última solicitud a la página de destino; reutilízalos en las solicitudes posteriores |
| `headers` | object | Encabezados de respuesta de la página de destino después de pasar la verificación |
| `content` | string | Código fuente HTML de la página de destino después de pasar la verificación |
## Cómo usar el resultado
1. En las solicitudes posteriores usa **a la vez** las `cookies` devueltas, el `user_agent` devuelto y el mismo proxy que usaste al crear la tarea. `cf_clearance` está ligado al User-Agent y a la IP de salida; si cualquiera de los tres no coincide, volverá a aparecer la página de verificación.
2. Envía los encabezados de `request_headers` en la medida de lo posible y usa una huella TLS acorde con la del navegador (por ejemplo, la opción `impersonate` de curl\_cffi).
3. `cf_clearance` tiene un periodo de validez (lo define el sitio de destino; en algunos llega a 1 hora). Dentro de ese periodo no necesitas superar la comprobación otra vez; si envías solicitudes con demasiada frecuencia, Cloudflare puede bloquear tu IP.
4. Si solo necesitas el contenido de la página, puedes usar `content` directamente y no hace falta solicitarla de nuevo.
## Errores comunes
Los errores devueltos al crear la tarea no se cobran; si la tarea falla o se agota el tiempo después de crearse, se hace un reembolso de puntos automático. La API solo devuelve el código de error y una descripción genérica; consulta la causa concreta en la tabla.
| Código de error | Cuándo se devuelve | Qué hacer |
| --- | --- | --- |
| `ERROR_REQUIRED_FIELDS` | Al crear la tarea: falta `websiteURL` o `proxy` | Añade los dos campos obligatorios |
| `ERROR_ILLEGAL_PARAMETERS` | Al crear la tarea: `websiteURL` no es una URL pública que empiece por `http://` o `https://`, `postData` no es un objeto, o `requiredCookies` no es un arreglo de cadenas. Al consultar el resultado: no se pudo resolver el dominio de la URL de destino a través del proxy | Corrige los parámetros; revisa la ortografía de la URL y si el proxy puede acceder al sitio |
| `ERROR_PROXY_INCORRECT` | Al crear la tarea: el formato del proxy es incorrecto, falta el puerto, o se usó un proxy `https://` o socks5 con usuario y contraseña | Corrígelo según el formato de “Requisitos del proxy”; si necesitas usuario y contraseña, usa un proxy http |
| `ERROR_PROXY_BANNED` | Al crear la tarea: el proxy es una dirección local, de red interna o reservada, o no logró conectarse varias veces en poco tiempo. Al consultar el resultado: Cloudflare del sitio de destino bloqueó directamente la IP de este proxy (páginas “Sorry, you have been blocked” o “Access denied”) | Cambia de proxy; cuanto mejor sea la calidad de la IP, más fácil es pasar |
| `ERROR_PROXY_CONNECT_REFUSED` | No se pudo conectar al proxy (conexión rechazada, no se resuelve el dominio del proxy), o la conexión fue rechazada o restablecida al abrir la página a través del proxy | Revisa la dirección y el puerto del proxy, y confirma que está en línea y permite acceso externo; si sigue fallando, cambia de proxy |
| `ERROR_PROXY_CONNECT_TIMEOUT` | Se agotó el tiempo al conectar con el proxy o al abrir la página a través de él | Usa un proxy más rápido y estable |
| `ERROR_PROXY_NOT_AUTHORISED` | El usuario o la contraseña del proxy son incorrectos | Revisa el usuario y la contraseña en `proxy`; codifica en URL los caracteres especiales |
| `ERROR_PROXY_TLS_ERROR` | Error en el handshake TLS al abrir la página a través del proxy | Confirma que la dirección, el puerto y el protocolo del proxy son correctos; si sigue fallando, cambia de proxy |
| `ERROR_CAPTCHA_UNSOLVABLE` | No se superó la comprobación en el tiempo establecido, la página seguía en la comprobación tras superarla, o no se obtuvo una cookie requerida en `requiredCookies` | Prueba primero con otro proxy; en sitios concretos puedes contactar con soporte |
| `ERROR_NO_SLOT_AVAILABLE` | Al crear la tarea: la cola está llena. Al consultar el resultado: la tarea esperó demasiado en la cola sin empezar, y se reembolsaron los puntos | Espera unos segundos y vuelve a crear la tarea |
| `ERROR_TASK_TIMEOUT` | La tarea no se completó en el tiempo establecido | Vuelve a crear la tarea; si los tiempos de espera se repiten, normalmente el proxy es demasiado lento |
Consulta todos los códigos de error en [Códigos de error](https://docs.yescaptcha.com/es/api/errors.md).
## Relacionado
- [Identificar el tipo de captcha](https://docs.yescaptcha.com/es/guides/identify-captcha.md): la diferencia entre la página de verificación de Cloudflare y Turnstile
- [Cloudflare Turnstile](https://docs.yescaptcha.com/es/tasks/turnstile.md)
---
# Imagen a texto
> Lee las letras y los dígitos de una imagen con YesCaptcha. ImageToTextTaskOcrBase e ImageToTextTaskMuggle devuelven el resultado de forma síncrona; ImageToTextTask e ImageToTextTaskM1 son asíncronos y admiten mayúsculas/minúsculas, solo dígitos, operaciones matemáticas y límites de longitud; hay modelos personalizados disponibles.
Source: https://docs.yescaptcha.com/es/tasks/image-to-text/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/tasks/image-to-text/
Envía la imagen de un captcha de texto en Base64 y recibe las letras y los dígitos que contiene (`solution.text`). `ImageToTextTaskOcrBase` cuesta 2 puntos (≈ $0.30 / 1k) por imagen y es síncrono: una sola solicitud `createTask` devuelve el resultado. Si necesitas opciones como distinguir mayúsculas y minúsculas, solo dígitos u operaciones matemáticas, usa el `ImageToTextTask` asíncrono.
- POST `https://api.yescaptcha.com/createTask` (Endpoint global)
- POST `https://cn.yescaptcha.com/createTask` (Endpoint China)
El cuerpo de la solicitud es JSON y se autentica con tu `clientKey`.
## Tipos y precios
| Tipo de tarea | Precio | Modo | Notas |
| --- | --- | --- | --- |
| `ImageToTextTaskOcrBase` | $0.30 / 1k; 2 puntos/tarea · ¥2 / 1k | Síncrono | |
| `ImageToTextTaskMuggle` | $0.30 / 1k; 2 puntos/tarea · ¥2 / 1k | Síncrono | No admite las opciones case/numeric; usa project\_name para elegir un modelo personalizado |
| `ImageToTextTask` | $0.60 / 1k; 4 puntos/tarea · ¥4 / 1k | Asíncrono | |
| `ImageToTextTaskM1` | $2.25 / 1k; 15 puntos/tarea · ¥15 / 1k | Asíncrono | |
Los precios en dólares son estimaciones con US$1 ≈ ¥6.67; las tareas se cobran en puntos.
| Necesitas | Usa |
| --- | --- |
| Captchas alfanuméricos normales, el más barato y rápido | `ImageToTextTaskOcrBase`, `ImageToTextTaskMuggle` (síncronos) |
| Un modelo entrenado para ti | `ImageToTextTaskMuggle` con `project_name` |
| Distinguir mayúsculas y minúsculas, solo dígitos, operaciones matemáticas, límites de longitud | `ImageToTextTask`, `ImageToTextTaskM1` (asíncronos) |
Cada tipo usa modelos y rutas distintos, así que el resultado con el mismo tipo de imagen puede variar; pruébalos y elige el mejor.
## Parámetros de la solicitud
| Campo | Tipo | Obligatorio | Descripción |
| --- | --- | --- | --- |
| `type` | string | Sí | Tipo de tarea; consulta "Tipos de tarea y precios" en esta página |
| `body` | string | Sí | Imagen codificada en Base64, sin el prefijo `data:image/...;base64,` y sin saltos de línea |
| `project_name` | string | No | Nombre de un modelo personalizado, compatible solo con `ImageToTextTaskMuggle`. Omítelo para usar el modelo alfanumérico general. Contacta a Soporte para obtener un modelo personalizado (solo ImageToTextTaskMuggle) |
| `phrase` | boolean | No | true significa que la respuesta contiene al menos un espacio (solo ImageToTextTask, ImageToTextTaskM1) |
| `case` | boolean | No | true significa que la respuesta distingue entre mayúsculas y minúsculas (solo ImageToTextTask, ImageToTextTaskM1) |
| `numeric` | integer | No | 0 sin requisito; 1 solo dígitos; 2 sin dígitos (solo ImageToTextTask, ImageToTextTaskM1) |
| `math` | boolean | No | true significa que la imagen es una expresión matemática y la respuesta es su resultado (solo ImageToTextTask, ImageToTextTaskM1) |
| `minLength` | integer | No | Longitud mínima de la respuesta; 0 significa sin límite (solo ImageToTextTask, ImageToTextTaskM1) |
| `maxLength` | integer | No | Longitud máxima de la respuesta; 0 significa sin límite (solo ImageToTextTask, ImageToTextTaskM1) |
`body` es el Base64 del archivo de imagen. Las imágenes WebP se convierten automáticamente.
> **Precaución:** No incluyas el prefijo `data:image/...;base64,` ni saltos de línea en el Base64.
## Ejemplo de solicitud
POST https://api.yescaptcha.com/createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "ImageToTextTaskOcrBase",
"body": "BASE64_IMAGE"
}
}
```
Código completo (lee `captcha.png` del directorio actual):
**curl**
```bash
# Replace BASE64_IMAGE with the Base64-encoded image
curl -s https://api.yescaptcha.com/createTask \
-H 'Content-Type: application/json' \
-d '{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "ImageToTextTaskOcrBase",
"body": "BASE64_IMAGE"
}
}'
```
**Python**
solve.py
```python
import os
import base64
import requests
API = "https://api.yescaptcha.com"
CLIENT_KEY = os.environ["YESCAPTCHA_CLIENT_KEY"] # Read the clientKey from an environment variable
def call(method, payload):
r = requests.post(f"{API}/{method}", json={"clientKey": CLIENT_KEY, **payload}, timeout=30)
data = r.json()
if data.get("errorId"):
raise RuntimeError(f"{data.get('errorCode')}: {data.get('errorDescription')}")
return data
def solve(task):
return call("createTask", {"task": task})["solution"]
# Base64-encode the image (no data: prefix)
with open("captcha.png", "rb") as f:
image_b64 = base64.b64encode(f.read()).decode()
solution = solve({
"type": "ImageToTextTaskOcrBase",
"body": image_b64,
})
print(solution["text"])
```
**Node.js**
solve.mjs
```js
import { readFileSync } from 'node:fs';
const API = 'https://api.yescaptcha.com';
const CLIENT_KEY = process.env.YESCAPTCHA_CLIENT_KEY; // Read the clientKey from an environment variable
async function call(method, payload) {
const res = await fetch(`${API}/${method}`, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ clientKey: CLIENT_KEY, ...payload }),
});
const data = await res.json();
if (data.errorId) throw new Error(`${data.errorCode}: ${data.errorDescription}`);
return data;
}
async function solve(task) {
const { solution } = await call('createTask', { task });
return solution;
}
// Base64-encode the image (no data: prefix)
const imageB64 = readFileSync('captcha.png').toString('base64');
const solution = await solve({
type: "ImageToTextTaskOcrBase",
body: imageB64,
});
console.log(solution.text);
```
Una tarea asíncrona con opciones:
POST https://api.yescaptcha.com/createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "ImageToTextTask",
"body": "BASE64_IMAGE",
"case": true,
"numeric": 0,
"minLength": 4,
"maxLength": 6
}
}
```
## Resultado
Los tipos síncronos devuelven el resultado directamente en `createTask`:
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"text": "LMResm"
},
"taskId": "2376919c-1863-11ec-a012-94e6f7355a0b"
}
```
Los tipos asíncronos (`ImageToTextTask`, `ImageToTextTaskM1`) devuelven primero un `taskId`; después consulta `getTaskResult` cada 5 segundos. Al terminar, `solution` tiene el mismo formato.
| Campo | Tipo | Descripción |
| --- | --- | --- |
| `text` | string | El texto reconocido |
## Modelos personalizados
El modelo general funciona con cualquier captcha alfanumérico, pero es algo menos preciso que un modelo entrenado para un estilo concreto. Si las imágenes que quieres reconocer siempre tienen el mismo estilo, [contacta con soporte](https://docs.yescaptcha.com/es/help/contact.md) para pedir un modelo personalizado y luego selecciónalo con `ImageToTextTaskMuggle` y `project_name`.
## Preguntas frecuentes
### ¿Se cobran puntos si el texto es incorrecto?
En los tipos síncronos se cobran puntos siempre que se devuelve un resultado, aunque sea incorrecto. Prueba otro tipo para comparar o pide un modelo personalizado.
### ¿Recibo `ERROR_ZERO_CAPTCHA_FILESIZE` o `ERROR_PARSE_IMAGE_FAIL`?
El Base64 de la imagen está incompleto o incluye el prefijo `data:` o saltos de línea. Revisa la codificación; consulta los [códigos de error](https://docs.yescaptcha.com/es/api/errors.md).
## Ejemplos relacionados
- [Inicio rápido](https://docs.yescaptcha.com/es/getting-started/quickstart.md): tu primera solicitud con `ImageToTextTaskOcrBase`
- [Ejemplos en Python](https://docs.yescaptcha.com/es/samples/python.md)
---
# Reconocimiento de imágenes de reCAPTCHA v2
> Resuelve los desafíos de imágenes de reCAPTCHA v2 con YesCaptcha (ReCaptchaV2Classification): sube una imagen 3x3, 4x4 o 1x1 con el ID de la pregunta y recibe de forma síncrona las celdas que debes pulsar; precio según el tamaño de la imagen y tabla de IDs de preguntas.
Source: https://docs.yescaptcha.com/es/tasks/recaptcha-classification/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/tasks/recaptcha-classification/
`ReCaptchaV2Classification` reconoce los desafíos de imágenes de reCAPTCHA v2: envías la imagen y el ID de la pregunta, y recibes qué celdas hay que pulsar; tu programa hace los clics en el navegador. **No devuelve un token**. Es síncrono: una sola solicitud `createTask` devuelve el resultado. Cada imagen 3x3 o 4x4 cuesta 6 puntos (≈ $0.90 / 1k), y la imagen pequeña 1x1 es más barata (consulta la tabla).
> **Consejo:** Si no quieres escribir la lógica de clics, usa la [extensión del navegador](https://docs.yescaptcha.com/es/extension.md), que hace los clics automáticamente con esta misma API.
- POST `https://api.yescaptcha.com/createTask` (Endpoint global)
- POST `https://cn.yescaptcha.com/createTask` (Endpoint China)
## Tipos y precios
| Tipo de tarea | Precio | Modo | Notas |
| --- | --- | --- | --- |
| `ReCaptchaV2Classification` | $0.90 / 1k; 6 puntos/tarea · ¥6 / 1k | Síncrono | 2 puntos por una imagen de 1x1 (100x100); 6 puntos por 3x3 (300x300) y 4x4 (450x450) |
Los precios en dólares son estimaciones con US$1 ≈ ¥6.67; las tareas se cobran en puntos.
## Parámetros de la solicitud
| Campo | Tipo | Obligatorio | Descripción |
| --- | --- | --- | --- |
| `type` | string | Sí | Tipo de tarea; consulta "Tipos de tarea y precios" en esta página |
| `image` | string | Sí | Imagen del desafío codificada en Base64, sin el prefijo `data:` |
| `question` | string | Sí | ID de la pregunta, como `/m/0k4j`; consulta "ID de preguntas" en esta página |
| `confidence` | number | No | Umbral de confianza de 0 a 1, solo se usa para imágenes de 3x3. Si lo envías (0.5 es un buen punto de partida), se devuelven todas las celdas por encima del umbral; si lo omites, se devuelven las 3 celdas más probables |
> **Precaución:** La imagen debe escalarse a uno de los tamaños estándar de la tabla; el servidor determina el tipo de desafío por el tamaño.
| Tipo de desafío | Tamaño de la imagen | Devuelve |
| --- | --- | --- |
| Cuadrícula 3x3 (“Select all images with …”) | 300 × 300 | `objects`: celdas que hay que pulsar |
| Cuadrícula 4x4 (“Select all squares with …”) | 450 × 450 | `objects`: celdas que hay que pulsar |
| Imagen 1x1 (la imagen individual que aparece tras pulsar en una cuadrícula 3x3) | 100 × 100 | `hasObject`: si hay que pulsar esta imagen |
Si trabajas con capturas de pantalla, distingue el tipo por el texto de la pregunta: en 3x3 dice “Select all images with …” y en 4x4 dice “Select all squares with …”.
## Ejemplo de solicitud
POST https://api.yescaptcha.com/createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "ReCaptchaV2Classification",
"image": "BASE64_IMAGE",
"question": "/m/0k4j"
}
}
```
## Resultado
3x3 y 4x4:
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"objects": [1, 5, 8],
"type": "multi"
},
"taskId": "3a9e8cb8-3871-11ec-9794-94e6f7355a0b"
}
```
Imagen 1x1:
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"hasObject": true,
"type": "single"
}
}
```
| Campo | Tipo | Descripción |
| --- | --- | --- |
| `objects` | array | Índices de las imágenes en las que hay que hacer clic, empezando en 0, de izquierda a derecha y de arriba abajo |
| `hasObject` | boolean | Se devuelve para una imagen de 1x1; indica si la imagen contiene el objetivo |
| `type` | string | Tipo de desafío: `multi` (imagen de 3x3 o 4x4, consulta `objects`), `single` (imagen de 1x1, consulta `hasObject`); `drag` para las preguntas de arrastre de hCaptcha |
Las celdas se numeran desde 0, de izquierda a derecha y de arriba abajo:
## confidence: obtener de una vez todas las celdas que coinciden
Después de pulsar en una cuadrícula 3x3, normalmente aparecen imágenes 1x1 nuevas que hay que seguir evaluando. Si no te resulta práctico obtener esas imágenes (por ejemplo, al desarrollar para móvil), puedes enviar `confidence`:
- Si no lo envías, una imagen 3x3 devuelve las 3 celdas con mayor puntuación (reCAPTCHA exige pulsar al menos 3).
- Si lo envías (se recomienda `0.5`), se devuelven todas las celdas con una puntuación superior a ese valor, que pueden ser más o menos de 3; si ninguna coincide, se devuelve un arreglo vacío. Así no tienes que capturar las imágenes 1x1.
- No tiene efecto en imágenes 4x4 ni 1x1.
## IDs de preguntas
`question` recibe el ID de la pregunta (empieza con `/m/`), no el texto. El ID viene en la respuesta de la solicitud con la que reCAPTCHA carga el desafío (`reload` o `userverify`), junto con la imagen. La tabla siguiente muestra las preguntas más comunes; el texto en chino es solo de referencia:
16 en total
| ID de pregunta | Pregunta (inglés) |
| --- | --- |
| `/m/0pg52` | `taxis` |
| `/m/01bjv` | `bus` |
| `/m/04_sv` | `motorcycles` |
| `/m/013xlm` | `tractors` |
| `/m/01jk_4` | `chimneys` |
| `/m/014xcs` | `crosswalks` |
| `/m/015qff` | `traffic lights` |
| `/m/0199g` | `bicycles` |
| `/m/015qbp` | `parking meters` |
| `/m/0k4j` | `cars` |
| `/m/015kr` | `bridges` |
| `/m/019jd` | `boats` |
| `/m/0cdl1` | `palm trees` |
| `/m/09d_r` | `mountains or hills` |
| `/m/01pns0` | `fire hydrant` |
| `/m/01lynh` | `stairs` |
No hay preguntas que coincidan
`ERROR_UNKNOWN_QUESTION` indica que el ID es incorrecto o que esa pregunta aún no es compatible. `ERROR_UNKNOW_450x450_QUESTION` indica que esa pregunta aún no es compatible con imágenes 4x4; recarga el desafío en la página para obtener otro.
## Reporte y reembolso
Si la verificación falla tras los clics, repórtalo con [report](https://docs.yescaptcha.com/es/api/report.md) en un plazo de 1 hora; el reembolso de puntos se liquida unas 24 horas después. Las reglas están en [Facturación y reembolsos](https://docs.yescaptcha.com/es/getting-started/billing.md). Si la verificación se supera, repórtalo también con `isSuccess: true`.
## Tutoriales relacionados
- [Clics simulados en reCAPTCHA v2 con reconocimiento de imágenes (Selenium)](https://docs.yescaptcha.com/es/guides/recaptcha-click-selenium.md)
- [reCAPTCHA v2 (devuelve token)](https://docs.yescaptcha.com/es/tasks/recaptcha-v2.md)
---
# Reconocimiento de imágenes de hCaptcha
> Resuelve los desafíos de imágenes de hCaptcha con YesCaptcha (HCaptchaClassification): selección en cuadrícula 3×3, clic en una posición, arrastrar a una posición y preguntas animadas; respuesta síncrona, sin cobro de puntos cuando no se encuentra ningún objetivo.
Source: https://docs.yescaptcha.com/es/tasks/hcaptcha-classification/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/tasks/hcaptcha-classification/
`HCaptchaClassification` reconoce los desafíos de imágenes de hCaptcha: envías la pregunta y las imágenes, y recibes qué imágenes seleccionar, en qué posición hacer clic o desde dónde y hasta dónde arrastrar; tu programa realiza la acción en el navegador. **No devuelve token**. Es síncrono, cuesta 8 puntos (≈ $1.20 / 1k) por solicitud y no se cobran puntos cuando no se encuentra ningún objetivo (resultado vacío).
> **Consejo:** Si no quieres escribir la lógica de clics, puedes usar la [extensión del navegador](https://docs.yescaptcha.com/es/extension.md), que admite todos estos tipos de pregunta. Si necesitas un token en lugar de posiciones de clic, usa [hCaptcha](https://docs.yescaptcha.com/es/tasks/hcaptcha.md).
- POST `https://api.yescaptcha.com/createTask` (Endpoint global)
- POST `https://cn.yescaptcha.com/createTask` (Endpoint China)
## Tipos y precios
| Tipo de tarea | Precio | Modo | Notas |
| --- | --- | --- | --- |
| `HCaptchaClassification` | $1.20 / 1k; 8 puntos/tarea · ¥8 / 1k | Síncrono | No se cobran puntos cuando no se encuentra ningún objetivo |
Los precios en dólares son estimaciones con US$1 ≈ ¥6.67; las tareas se cobran en puntos.
## Parámetros de la solicitud
| Campo | Tipo | Obligatorio | Descripción |
| --- | --- | --- | --- |
| `type` | string | Sí | Tipo de tarea; consulta "Tipos de tarea y precios" en esta página |
| `queries` | array | Sí | Lista de imágenes del desafío codificadas en Base64, en el orden de la página (9 imágenes pequeñas para una cuadrícula 3×3) |
| `question` | string | No | La pregunta completa tal como aparece en la página (se recomienda chino simplificado o inglés), p. ej., `Please click each image containing a bicycle`. Envía al menos uno de `question` y `anchors`; se recomienda enviar ambos |
| `anchors` | array | No | Imágenes de ejemplo codificadas en Base64 que aparecen junto a la pregunta; obligatorias para las preguntas que las incluyen |
- Envía en `question` la frase completa tal como aparece en la página; no hace falta traducirla, pero se recomienda cambiar hCaptcha a chino simplificado o inglés. Las preguntas nuevas suelen admitirse enseguida; las categorías completamente nuevas, en un plazo de 3 días hábiles.
> **Precaución:** Si la pregunta muestra imágenes de ejemplo en la esquina superior derecha, envíalas en `anchors`. Las preguntas que solo se pueden resolver viendo las imágenes de ejemplo no se reconocen si no envías `anchors`.
## Selección en cuadrícula 3×3
La pregunta dice “Please click each image containing …” y debajo hay 9 imágenes. Pon en `queries` las 9 imágenes en Base64, en el orden de la página:
POST https://api.yescaptcha.com/createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "HCaptchaClassification",
"question": "Please click each image containing a bicycle",
"queries": ["BASE64_IMAGE_1", "BASE64_IMAGE_2"]
}
}
```
Respuesta:
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"objects": [true, false, false, true, true, false, true, true, false],
"top_k": [0, 3, 4, 6, 7],
"confidences": [1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 1.0, 0.0]
}
}
```
`objects` y `top_k` contienen la misma información: el primero indica para cada imagen si es un objetivo, y el segundo lista los índices de las imágenes objetivo (desde 0). Haz clic en esas imágenes.
## Clic en una posición
La pregunta dice “Please click on …” y debajo hay una imagen grande en la que debes hacer clic en una o varias posiciones.
1. Toma `question` de la página; si hay imágenes de ejemplo, ponlas en `anchors`.
2. Pon una imagen en `queries`: lo mejor es la imagen original exportada directamente del canvas (se recomienda convertirla a JPG). Si solo puedes hacer una captura de pantalla, captura el área de la imagen grande del recuadro rojo de abajo, sin que sobre ni falte nada.
3. `box` en la respuesta son las coordenadas donde hacer clic, en el orden x1, y1, x2, y2…, con el origen en la esquina superior izquierda de la imagen enviada.
4. Si el tamaño de la imagen enviada es distinto del que se muestra en la página, hay que convertir: x en la página = x devuelto × ancho mostrado ÷ ancho de la imagen enviada (igual para y). Por ejemplo, si se devuelve x = 769, el canvas se muestra con 350 de ancho y la imagen enviada tiene 1000 de ancho, en la página debes hacer clic en 769 × 350 ÷ 1000 ≈ 269.
POST https://api.yescaptcha.com/createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "HCaptchaClassification",
"question": "Please click on the entity present in the sample image.",
"anchors": ["BASE64_ANCHOR_1", "BASE64_ANCHOR_2", "BASE64_ANCHOR_3"],
"queries": ["BASE64_OF_THE_BIG_IMAGE"]
}
}
```
Respuesta:
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"box": ["221", "213"]
}
}
```
Cuando hay que hacer clic en varios objetivos, `box` contiene varios pares de coordenadas en orden: `["221", "213", "340", "118", ...]`.
## Arrastrar a una posición
La pregunta dice “Drag … to …” y debes arrastrar la pieza de la derecha a su posición correspondiente en la imagen.
1. Toma `question` de la página.
2. Haz una captura y ponla en `queries`; debe mostrar **a la vez** la pieza que se arrastra y la posición de destino, y cada lado de la imagen debe medir al menos 260 píxeles.
3. Cada elemento de `box` en la respuesta es un arrastre: `start` es la posición de la pieza y `end` es la posición a la que hay que arrastrarla. Si hay varias piezas, arrástralas una por una.
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"type": "drag",
"box": [
{
"start": [644, 218],
"end": [239, 315]
}
]
}
}
```
Si lo que tienes son datos del protocolo (la imagen de la pieza, sus coordenadas y la imagen de fondo) en lugar de una captura de pantalla, primero pega la pieza sobre la imagen de fondo según las coordenadas, para obtener una imagen con el mismo aspecto que la captura de la página, y luego envíala.
## Preguntas animadas
Cuando la imagen de la pregunta es una animación, pon en `queries` la animación (GIF u otro formato) en Base64. Se recomienda que dure al menos 3 segundos, idealmente de 5 a 6, a unos 12 FPS.
## Reporte y reembolso tras reportar
Si la verificación falla después de tus clics, puedes reportar la tarea con [report](https://docs.yescaptcha.com/es/api/report.md) en un plazo de 1 hora; el reembolso se liquida en unas 24 horas. Las reglas están en [Facturación y reembolsos](https://docs.yescaptcha.com/es/getting-started/billing.md).
## Guías relacionadas
- [Clics de reconocimiento de imágenes de hCaptcha con Selenium](https://docs.yescaptcha.com/es/guides/hcaptcha-click-selenium.md)
---
# Reconocimiento de imágenes de FunCaptcha
> Reconoce los puzzles de imágenes de FunCaptcha (Arkose Labs) con YesCaptcha (FunCaptchaClassification). Sube la imagen del puzzle (una cuadrícula de 6 imágenes o un puzzle de flechas con dos mitades) y la pregunta en inglés, y obtén de forma síncrona qué imagen elegir; se admiten todos los tipos de puzzle.
Source: https://docs.yescaptcha.com/es/tasks/funcaptcha-classification/ · Last verified: 2026-10-16
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/tasks/funcaptcha-classification/
`FunCaptchaClassification` reconoce los puzzles de imágenes de FunCaptcha (Arkose Labs): envía la imagen del puzzle y la pregunta en inglés, y recibirás qué imagen elegir; tu programa hace el clic en el navegador. **No devuelve token**. Es síncrono y cuesta 3 puntos (≈ $0.45 / 1k) por solicitud.
> **Consejo:** Si no quieres escribir código, usa la [extensión del navegador](https://docs.yescaptcha.com/es/extension.md) para resolverlo automáticamente en la página.
- POST `https://api.yescaptcha.com/createTask` (Endpoint global)
- POST `https://cn.yescaptcha.com/createTask` (Endpoint China)
## Tipos de tarea y precios
| Tipo de tarea | Precio | Modo | Notas |
| --- | --- | --- | --- |
| `FunCaptchaClassification` | $0.45 / 1k; 3 puntos/tarea · ¥3 / 1k | Síncrono | |
Los precios en dólares son estimaciones con US$1 ≈ ¥6.67; las tareas se cobran en puntos.
## Parámetros de la solicitud
| Campo | Tipo | Obligatorio | Descripción |
| --- | --- | --- | --- |
| `type` | string | Sí | Tipo de tarea; consulta "Tipos de tarea y precios" en esta página |
| `image` | string | Sí | Imagen del desafío codificada en Base64, sin el prefijo `data:` |
| `question` | string | Sí | El texto de la pregunta en inglés (p. ej., `Pick the image that is the correct way up`); las preguntas compatibles se enumeran en esta página |
- `image` solo incluye la parte de imágenes del puzzle (una cuadrícula de 6 imágenes, o la imagen con las dos mitades del puzzle de flechas); no incluyas el título ni los botones de arriba. La captura debe estar completa: si falta un trozo, se reduce la precisión. Las cuadrículas de 6 imágenes en vertical se pueden subir tal cual, con la imagen original.
- `question` es el texto completo de la pregunta en inglés tal como aparece en la página, con las mayúsculas y minúsculas exactas; no la traduzcas. Si la página está en otro idioma, cambia primero el captcha a inglés. El servidor determina el tipo de puzzle a partir de la pregunta, así que debe ser correcta.
## Ejemplo de solicitud
POST https://api.yescaptcha.com/createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "FunCaptchaClassification",
"image": "BASE64_IMAGE",
"question": "Pick the bread"
}
}
```
## Resultado
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"objects": [4],
"labels": ["parrot", "panda", "octopus", "owl", "bread", "dog"]
},
"taskId": "04a3fa76-11a0-11ed-a58c-0ef20f419382"
}
```
| Campo | Tipo | Descripción |
| --- | --- | --- |
| `objects` | array | Índice de la imagen que se debe seleccionar, empezando en 0, de izquierda a derecha y de arriba abajo |
| `labels` | array | Etiquetas reconocidas |
`objects: [4]` significa que debes elegir la 5.ª imagen (los índices empiezan en 0, de izquierda a derecha y de arriba abajo). Un reto suele tener varias rondas seguidas; en cada ronda debes volver a capturar la imagen y volver a llamar a la API.
## Preguntas admitidas
**Se admiten todos los tipos de puzzle**, no hace falta consultar antes una lista: envía directamente la pregunta en inglés y la imagen del puzzle tal como aparecen en la página. Si recibes `ERROR_UNKNOWN_QUESTION`, [contacta con soporte](https://docs.yescaptcha.com/es/help/contact.md).
El tipo más común ahora es el puzzle de flechas con dos mitades: a la izquierda está el ejemplo con el que hay que comparar y a la derecha la imagen actual, que cambias con las flechas hasta encontrar la que cumple la pregunta. Sube la imagen completa (ambas mitades) tal como se ve en la página. Por ejemplo:
`Use the arrows to change the number of objects until it matches the left image`La cantidad coincide con la imagen de la izquierda
`use the arrows to choose the image where all the darts add up to the number in the left image`La suma de los números de los dardos es igual al número de la imagen de la izquierda
`use the arrows to find the jigsaw puzzle that is missing the puzzle piece shown on the left`Falta justo la pieza que se muestra a la izquierda
`find the image that has the prize on the left held by the claw in the machine on the right`La garra sujeta el premio de la izquierda
El otro tipo es el puzzle de cuadrícula de 6 imágenes (como `Pick the bread`): sube solo la parte con las 6 imágenes, como en el ejemplo de solicitud de arriba.
## Reporte y reembolso
Si el envío final de un grupo de preguntas falla y no sabes en qué ronda estuvo el error, puedes reportar con [report](https://docs.yescaptcha.com/es/api/report.md) los ID de tarea de todo el grupo (dentro de 1 hora). El reembolso tras reportar se liquida unas 24 horas después; consulta las reglas en [Facturación y reembolsos](https://docs.yescaptcha.com/es/getting-started/billing.md).
---
# Reconocimiento de imágenes AWS WAF / bCaptcha
> Reconoce con YesCaptcha los desafíos de imágenes en cuadrícula 3×3 de AWS WAF CAPTCHA y bCaptcha (AwsClassification, bCaptchaClassification). Sube la imagen completa y la pregunta, y recibe de forma síncrona las celdas en las que debes hacer clic.
Source: https://docs.yescaptcha.com/es/tasks/aws-bcaptcha-classification/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/tasks/aws-bcaptcha-classification/
`AwsClassification` reconoce los desafíos de imágenes en cuadrícula 3×3 de AWS WAF CAPTCHA y `bCaptchaClassification` reconoce los de bCaptcha: envía la imagen completa y la pregunta, y recibirás qué celdas debes pulsar; tu programa hace clic en ellas en el navegador. **No devuelven token**. Son síncronos y cada solicitud cuesta 8 puntos (≈ $1.20 / 1k).
Si no quieres escribir código, usa la [extensión del navegador](https://docs.yescaptcha.com/es/extension.md).
- POST `https://api.yescaptcha.com/createTask` (Endpoint global)
- POST `https://cn.yescaptcha.com/createTask` (Endpoint China)
## Tipos y precios
| Tipo de tarea | Precio | Modo | Notas |
| --- | --- | --- | --- |
| `AwsClassification` | $1.20 / 1k; 8 puntos/tarea · ¥8 / 1k | Síncrono | |
| `bCaptchaClassification` | $1.20 / 1k; 8 puntos/tarea · ¥8 / 1k | Síncrono | |
Los precios en dólares son estimaciones con US$1 ≈ ¥6.67; las tareas se cobran en puntos.
Los dos tipos tienen los mismos parámetros y el mismo formato de respuesta; elige según el origen del captcha: `AwsClassification` para AWS WAF y `bCaptchaClassification` para bCaptcha.
## Parámetros de la solicitud
| Campo | Tipo | Obligatorio | Descripción |
| --- | --- | --- | --- |
| `type` | string | Sí | Tipo de tarea; consulta "Tipos de tarea y precios" en esta página |
| `queries` | string | Sí | Base64 de la imagen completa de la cuadrícula 3×3 (una sola imagen) |
| `question` | string | No | La pregunta completa tal como aparece en la página, p. ej., `Select all hats`; los demás idiomas se traducen automáticamente |
`queries` contiene la imagen **completa** de la cuadrícula 3×3 (una sola imagen, no 9 piezas). Toma `question` tal cual aparece en la página, la frase completa; sirven el chino y el inglés, y otros idiomas se traducen automáticamente.
## Ejemplo de solicitud
POST https://api.yescaptcha.com/createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "AwsClassification",
"queries": "BASE64_IMAGE",
"question": "Select all hats"
}
}
```
## Resultado
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"label": "Select All Hats",
"objects": [false, true, false, false, true, true, true, true, false],
"top_k": [1, 4, 5, 6, 7],
"confidences": [0.0, 1.0, 0.0, 0.255, 1.0, 1.0, 0.9637, 0.9999, 0.0]
},
"taskId": "2053f690-3c3b-11f0-8ffb-d2c180657082"
}
```
| Campo | Tipo | Descripción |
| --- | --- | --- |
| `label` | string | El objetivo reconocido de la pregunta |
| `objects` | array | Si cada una de las 9 celdas es un objetivo (true / false), de izquierda a derecha y de arriba abajo |
| `top_k` | array | Índices (desde 0) de las imágenes que son objetivos; tiene el mismo significado que `objects`, usa cualquiera de los dos |
| `confidences` | array | Confianza de cada resultado |
Las 9 celdas se numeran de 0 a 8 en una cuadrícula 3×3, de izquierda a derecha y de arriba abajo. `objects` y `top_k` significan lo mismo; usa el que prefieras: haz clic en las celdas donde `objects` sea `true`, o en los índices de `top_k`.
## Reporte y reembolso tras reportar
Si la verificación falla después de hacer clic, puedes reportarlo con [report](https://docs.yescaptcha.com/es/api/report.md) dentro de 1 hora; el reembolso se liquida pasadas unas 24 horas. Las reglas están en [Facturación y reembolso de puntos](https://docs.yescaptcha.com/es/getting-started/billing.md).
---
# YesCaptcha Assistant
> YesCaptcha Assistant (extensión del navegador) para Chrome y Firefox: reconoce y hace clic automáticamente en reCAPTCHA, hCaptcha, FunCaptcha, AWS WAF y otros captchas. La extensión es gratis; se cobran los puntos de las API que usa para reconocer. Enlaces de las tiendas, descarga de los paquetes y videos de instalación en Chrome, BitBrowser y Kiwi Browser.
Source: https://docs.yescaptcha.com/es/extension/ · Last verified: 2026-10-24
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/extension/
YesCaptcha Assistant es una extensión del navegador para Chrome y Firefox: cuando abres una página con un captcha, envía el desafío a YesCaptcha para reconocerlo y hace clic automáticamente, sin escribir código. La extensión es gratis; al reconocer se cobran puntos según la API que usa, con la misma cuenta y el mismo saldo que la API.
## Qué puede hacer
- Reconoce y hace clic automáticamente en las preguntas con imágenes de reCAPTCHA v2, hCaptcha, FunCaptcha, AWS WAF y bCaptcha.
- Captchas de texto normales: haz clic derecho en la imagen y elige “Marcar como captcha”, luego haz clic derecho en el campo de entrada y elige “Introducir captcha”; la extensión lo reconoce y lo escribe.
- En la configuración puedes activar o desactivar cada tipo de captcha por separado, y ajustar la velocidad de clic, los reintentos tras un fallo, etc.
> **Nota:** No todos los sitios se pueden superar; te recomendamos probar primero.
## Instalación
**Desde la tienda (recomendado, se actualiza automáticamente):**
- Chrome (y navegadores basados en Chromium como Edge): [Chrome Web Store](https://chromewebstore.google.com/detail/yescaptcha-assistant/jiofmdifioeejeilfkpegipdjiopiekl)
- Firefox: [Complementos de Firefox](https://addons.mozilla.org/firefox/addon/yescaptcha-assistant/)
Abre la página de la extensión en Chrome Web Store, haz clic en “Añadir a Chrome”, luego haz clic en el icono de la extensión en la barra de herramientas e introduce tu `clientKey`:
Tu navegador no puede reproducir este video. Descárgalo en su lugar: [Video: instalación desde Chrome Web Store (34 s)](https://docs.yescaptcha.com/videos/extension-chrome-store.mp4)
Video: instalación desde Chrome Web Store (34 s)
**Si no puedes abrir la tienda, descarga el paquete:**
Versión para Chrome
Versión
1.4.12
Tamaño
1.1 MB
Actualizado
2026-11-10
[Descargar](https://api.yescaptcha.com/extension/chrome/latest)[Chrome Web Store](https://chromewebstore.google.com/detail/yescaptcha-assistant/jiofmdifioeejeilfkpegipdjiopiekl)
Versión para Firefox
Versión
0.4.6
Tamaño
0.9 MB
Actualizado
2026-10-31
[Descargar](https://api.yescaptcha.com/extension/firefox/latest)[Complementos de Firefox](https://addons.mozilla.org/firefox/addon/yescaptcha-assistant/)
La versión de la tienda de Firefox puede ser más antigua que el paquete de aquí; si necesitas la última versión, usa el paquete.
### Instalar el paquete en Chrome
1. Descarga el archivo zip y extráelo en una carpeta permanente.
2. Abre `chrome://extensions` en la barra de direcciones y activa el “Modo de desarrollador” en la esquina superior derecha.
3. Haz clic en “Cargar descomprimida” y elige la carpeta que acabas de extraer.
4. Haz clic en el icono de la extensión en la barra de herramientas e introduce tu `clientKey`.
También puedes, antes de cargarla, abrir con un editor de texto el archivo `config.js` extraído, escribir tu `clientKey` entre las comillas de `clientKey: ''` y guardar; así no tendrás que introducirla después de instalar. Es más cómodo cuando instalas la extensión en varios perfiles del navegador.
Tu navegador no puede reproducir este video. Descárgalo en su lugar: [Video: instalación del paquete en Chrome, con el clientKey ya escrito en config.js (44 s; el video usa una versión anterior, los pasos son los mismos)](https://docs.yescaptcha.com/videos/extension-chrome-zip.mp4)
Video: instalación del paquete en Chrome, con el clientKey ya escrito en config.js (44 s; el video usa una versión anterior, los pasos son los mismos)
> **Precaución:** No borres ni muevas después la carpeta extraída, o el navegador no podrá cargar la extensión. Las extensiones instaladas con el paquete no se actualizan automáticamente; cuando haya una versión nueva, tendrás que descargarla de nuevo.
### Instalar el paquete en Firefox
1. Descarga el archivo `.xpi`.
2. Abre `about:addons` en la barra de direcciones, haz clic en el icono de engranaje, elige “Instalar complemento desde archivo” y selecciona el archivo descargado.
3. Haz clic en el icono de la extensión en la barra de herramientas e introduce tu `clientKey`.
## Instalar en BitBrowser
Los navegadores antidetección (anti-detect browser) como BitBrowser usan el motor de Chrome. La extensión se añade desde su Extension Center (扩展中心) y después se puede asignar a todos los perfiles o solo a algunos. Los pasos y los videos de abajo se grabaron con BitBrowser 6.0 en su interfaz en chino; en versiones más nuevas la interfaz puede ser ligeramente distinta.
### Desde Chrome Web Store
1. En BitBrowser, haz clic en Extension Center (扩展中心) en la barra lateral izquierda, luego en “Añadir extensión personalizada” (添加自定义扩展) y elige “Añadir extensión de Chrome Web Store” (添加 Chrome 商店扩展).
2. En el campo de la URL de detalles de la extensión, pega la dirección de la extensión en Chrome Web Store `https://chromewebstore.google.com/detail/yescaptcha-assistant/jiofmdifioeejeilfkpegipdjiopiekl` y haz clic en el botón a la derecha del campo para reconocerla. Cuando aparezca YesCaptcha Assistant, haz clic en Aceptar.
3. Después de añadirla, en la tarjeta de YesCaptcha Assistant haz clic en Configuración (设置), elige dónde se activa (todos los perfiles, o solo los perfiles que marques) y haz clic en Aceptar.
4. Abre un perfil del navegador, haz clic en el icono de extensiones de la barra de herramientas, abre YesCaptcha Assistant e introduce tu `clientKey`. Si ves tu saldo, ya está configurado.
Tu navegador no puede reproducir este video. Descárgalo en su lugar: [Video: añadir la extensión desde Chrome Web Store en BitBrowser (30 s)](https://docs.yescaptcha.com/videos/extension-bit-store.mp4)
Video: añadir la extensión desde Chrome Web Store en BitBrowser (30 s)
### Desde el paquete
1. Descarga el paquete de Chrome de arriba y extráelo en una carpeta permanente.
2. (Opcional) Abre con un editor de texto el archivo `config.js` de la carpeta, escribe tu `clientKey` entre las comillas de `clientKey: ''` y guarda. Así no tendrás que introducirla en cada perfil después de instalar.
3. En Extension Center haz clic en “Añadir extensión personalizada”, elige “Añadir extensión local” (添加本地扩展), selecciona la carpeta extraída (el nivel donde está `manifest.json`) y haz clic en Aceptar.
4. Cuando termine la carga, en la tarjeta de YesCaptcha Assistant haz clic en Configuración, elige dónde se activa (todos los perfiles o los que marques) y haz clic en Aceptar.
5. Abre un perfil del navegador y haz clic en YesCaptcha Assistant dentro del icono de extensiones. Si ves tu clave y tu saldo, ya está configurado.
Tu navegador no puede reproducir este video. Descárgalo en su lugar: [Video: añadir el paquete en BitBrowser (46 s; el video usa una versión anterior, los pasos son los mismos)](https://docs.yescaptcha.com/videos/extension-bit-zip.mp4)
Video: añadir el paquete en BitBrowser (46 s; el video usa una versión anterior, los pasos son los mismos)
## En un teléfono Android (Kiwi Browser)
> **Precaución:** Kiwi Browser dejó de recibir mantenimiento en enero de 2025 y fue retirado de Google Play, por lo que ya no recibe actualizaciones ni parches de seguridad. Los pasos y el video de abajo vienen de la documentación anterior, como referencia para quienes todavía usan Kiwi Browser; la versión actual de la extensión no se ha vuelto a probar en Kiwi Browser.
1. Descarga el paquete de Chrome (`.zip`) en el teléfono, sin extraerlo. Si necesitas dejar la clave ya escrita, extráelo antes en un ordenador, edita `config.js` y vuelve a comprimirlo en un zip (`manifest.json` debe quedar en el nivel superior del archivo comprimido).
2. En Kiwi Browser, toca el menú de la esquina superior derecha y elige “Extensions” (extensiones).
3. Activa “Developer mode” (modo de desarrollador), toca “+ (from .zip/.crx/.user.js)” y selecciona el paquete descargado.
4. Abre de nuevo el menú de la esquina superior derecha; al final aparecerá YesCaptcha Assistant. Tócalo e introduce tu `clientKey`. Si ves tu saldo, ya está configurado.
Tu navegador no puede reproducir este video. Descárgalo en su lugar: [Video: instalación en Kiwi Browser (16 s; el video usa una versión anterior, los pasos son los mismos)](https://docs.yescaptcha.com/videos/extension-kiwi.mp4)
Video: instalación en Kiwi Browser (16 s; el video usa una versión anterior, los pasos son los mismos)
## Configuración
1. Crea una cuenta y recarga el saldo en [yescaptcha.com](https://yescaptcha.com/), y copia tu `clientKey` en el Panel; consulta [Inicio rápido](https://docs.yescaptcha.com/es/getting-started/quickstart.md).
2. Haz clic en el icono de la extensión e introduce la clave en el panel de configuración. Si ves tu saldo, ya está configurado.
3. Abre una página con un captcha y la extensión empezará a reconocerlo automáticamente.
## Costo
La extensión es gratis. Al reconocer se cobran puntos según el tipo de tarea que se use; por ejemplo, las preguntas con imágenes de reCAPTCHA se cobran según [reconocimiento de imágenes de reCAPTCHA v2](https://docs.yescaptcha.com/es/tasks/recaptcha-classification.md), y hCaptcha según [reconocimiento de imágenes de hCaptcha](https://docs.yescaptcha.com/es/tasks/hcaptcha-classification.md). Si el resultado es incorrecto, puedes reportarlo para solicitar un reembolso; consulta [Facturación y reembolsos de puntos](https://docs.yescaptcha.com/es/getting-started/billing.md).
---
# Identificar el tipo de captcha
> Cómo saber qué captcha usa una página (reCAPTCHA v2, v2 invisible, v3, Enterprise, hCaptcha, y la diferencia entre Cloudflare Turnstile y la página de verificación de Cloudflare) y qué tipo de tarea de YesCaptcha usar.
Source: https://docs.yescaptcha.com/es/guides/identify-captcha/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/guides/identify-captcha/
El primer paso para elegir el tipo de tarea correcto es reconocer el captcha. Lo más fiable es abrir las herramientas de desarrollo del navegador (F12) y ver en el panel Network qué script de captcha carga la página; también puedes identificarlo por su aspecto.
## Identificar por el aspecto
Así se ve cada captcha en una página web (animaciones ilustrativas, no capturas de pantalla); haz clic en una tarjeta para abrir la página de su tipo de tarea. Si el aspecto no es concluyente, confírmalo con la tabla de referencia rápida y el panel Network que aparecen a continuación.
- [reCAPTCHA v2: Casilla · Invisible](https://docs.yescaptcha.com/es/tasks/recaptcha-v2.md)
- [reCAPTCHA v3](https://docs.yescaptcha.com/es/tasks/recaptcha-v3.md)
- [Reconocimiento de imágenes de reCAPTCHA v2: Cuadrícula 3×3 · Cuadrícula 4×4 · Imagen única 1×1](https://docs.yescaptcha.com/es/tasks/recaptcha-classification.md)
- [hCaptcha](https://docs.yescaptcha.com/es/tasks/hcaptcha.md)
- [Reconocimiento de imágenes de hCaptcha: Cuadrícula de imágenes · Clic en un punto · Arrastrar y soltar · Animado](https://docs.yescaptcha.com/es/tasks/hcaptcha-classification.md)
- [Cloudflare Turnstile: Automático · Casilla](https://docs.yescaptcha.com/es/tasks/turnstile.md)
- [Página de verificación de Cloudflare (5 segundos): Automático · Casilla](https://docs.yescaptcha.com/es/tasks/cloudflare-challenge.md)
- [Reconocimiento de imágenes de FunCaptcha: Flechas · Cuadrícula de 6 imágenes](https://docs.yescaptcha.com/es/tasks/funcaptcha-classification.md)
- [Reconocimiento de imágenes AWS WAF / bCaptcha: AWS WAF · bCaptcha](https://docs.yescaptcha.com/es/tasks/aws-bcaptcha-classification.md)
- [Imagen a texto: Con ruido · Líneas de ruido · Matemático](https://docs.yescaptcha.com/es/tasks/image-to-text.md)
## Referencia rápida
| Lo que ves | Qué es | Tipo de tarea |
| --- | --- | --- |
| Una casilla “No soy un robot” (“I’m not a robot”) | reCAPTCHA v2 | [reCAPTCHA v2](https://docs.yescaptcha.com/es/tasks/recaptcha-v2.md) |
| Sin casilla; el desafío de imágenes aparece al hacer clic en enviar; hay una pequeña insignia de reCAPTCHA en la esquina inferior derecha | reCAPTCHA v2 invisible (o v3) | Consulta “Versiones de reCAPTCHA” más abajo |
| Sin ninguna interacción; solo la insignia de reCAPTCHA en la esquina inferior derecha | reCAPTCHA v3 | [reCAPTCHA v3](https://docs.yescaptcha.com/es/tasks/recaptcha-v3.md) |
| Una casilla “Soy humano” y desafíos de imágenes con la marca hCaptcha | hCaptcha | [hCaptcha](https://docs.yescaptcha.com/es/tasks/hcaptcha.md) |
| Un cuadro de verificación de Cloudflare dentro de un formulario; la página no cambia tras marcarlo | Cloudflare Turnstile | [Turnstile](https://docs.yescaptcha.com/es/tasks/turnstile.md) |
| Toda la página muestra “Un momento…” / “Comprobando su conexión” y luego redirige automáticamente | Página de verificación de Cloudflare | [Página de verificación de Cloudflare](https://docs.yescaptcha.com/es/tasks/cloudflare-challenge.md) |
| Puzzles de Arkose Labs (como “Elige la imagen que está correctamente orientada hacia arriba”) | FunCaptcha | [Reconocimiento de imágenes de FunCaptcha](https://docs.yescaptcha.com/es/tasks/funcaptcha-classification.md) |
| Una imagen con letras y números distorsionados | Captcha de caracteres | [Imagen a texto](https://docs.yescaptcha.com/es/tasks/image-to-text.md) |
## Versiones de reCAPTCHA
Busca `api.js` o `enterprise.js` en el panel Network:
| Script cargado | Versión |
| --- | --- |
| `recaptcha/api.js`, sin el parámetro `render` o con `render=explicit` | v2 estándar |
| Igual que arriba, y la URL de la petición `anchor` contiene `size=invisible` | v2 invisible: añade `"isInvisible": true` a la tarea |
| `recaptcha/api.js?render=CLAVE_DEL_SITIO` (`render` no es `explicit`) | v3 estándar |
| `recaptcha/enterprise.js`, sin el parámetro `render` o con `render=explicit` | v2 Enterprise |
| `recaptcha/enterprise.js?render=CLAVE_DEL_SITIO` | v3 Enterprise |
Ejemplos:
```text
https://www.google.com/recaptcha/api.js?onload=onloadcallback&render=explicit → v2
https://www.google.com/recaptcha/api.js?render=6LdyC2cUAAAAACGuDKpXeDorzUDWXmdqeg-xy696 → v3
https://www.google.com/recaptcha/enterprise.js?render=explicit → v2 Enterprise
```
La v2 invisible a veces solo pasa con un tipo de v3; prueba ambos.
También puedes ejecutar el siguiente código en la consola (Console) del navegador. Lista todos los reCAPTCHA de la página con su versión, la clave del sitio, la URL de la página y la función callback:
find-recaptcha-clients.js
```js
// Paste into the browser DevTools console on a page with reCAPTCHA, then run findRecaptchaClients().
// Lists every reCAPTCHA on the page: version (V2/V3), sitekey, page URL and the callback function.
function findRecaptchaClients() {
if (typeof ___grecaptcha_cfg === 'undefined') return [];
return Object.entries(___grecaptcha_cfg.clients).map(([cid, client]) => {
const data = { id: cid, version: cid >= 10000 ? 'V3' : 'V2' };
const objects = Object.entries(client).filter(([, value]) => value && typeof value === 'object');
objects.forEach(([toplevelKey, toplevel]) => {
const found = Object.entries(toplevel).find(
([, value]) => value && typeof value === 'object' && 'sitekey' in value && 'size' in value,
);
if (toplevel instanceof HTMLElement && toplevel.tagName === 'DIV') data.pageurl = toplevel.baseURI;
if (found) {
const [sublevelKey, sublevel] = found;
data.sitekey = sublevel.sitekey;
const callbackKey = data.version === 'V2' ? 'callback' : 'promise-callback';
const callback = sublevel[callbackKey];
if (!callback) {
data.callback = null;
data.function = null;
} else {
data.function = callback;
const keys = [cid, toplevelKey, sublevelKey, callbackKey].map((key) => `['${key}']`).join('');
data.callback = `___grecaptcha_cfg.clients${keys}`;
}
}
});
return data;
});
}
findRecaptchaClients();
```
Ejemplo de resultado:
```json
[
{
"id": "0",
"version": "V2",
"sitekey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
"function": "onSuccess",
"callback": "___grecaptcha_cfg.clients['0']['l']['l']['callback']",
"pageurl": "https://www.google.com/recaptcha/api2/demo"
}
]
```
Las páginas de demostración oficiales de Google sirven para comparar: v2 estándar `https://www.google.com/recaptcha/api2/demo`, v2 invisible `https://www.google.com/recaptcha/api2/demo?invisible=true`.
## Turnstile y la página de verificación de Cloudflare
Ambos son de Cloudflare, pero no son lo mismo:
- **Turnstile** es un cuadro de verificación incrustado en el formulario de la página. Al completarse se marca con una palomita y la página no cambia. La página carga `challenges.cloudflare.com/turnstile/v0/api.js`. Usa [Turnstile](https://docs.yescaptcha.com/es/tasks/turnstile.md).
- **La página de verificación de Cloudflare** reemplaza toda la página por la pantalla de comprobación de Cloudflare, que muestra “Un momento…” o “xx.com necesita comprobar la seguridad de su conexión antes de continuar”; puede contener también un cuadro de verificación. Al superarla, redirige automáticamente a la página real. El código fuente contiene `__cf_chl_rt_tk` o `cdn-cgi/challenge-platform`. Usa [Página de verificación de Cloudflare](https://docs.yescaptcha.com/es/tasks/cloudflare-challenge.md).
Si tu programa recibe un 403 con “Just a moment…” pero el navegador abre la página sin problema, lo más probable es que solo se esté bloqueando la huella TLS. Una biblioteca que imite la huella TLS de un navegador (por ejemplo, curl\_cffi) permite hacer la petición sin necesidad de resolver la verificación.
---
# Encontrar los parámetros de reCAPTCHA
> Cómo encontrar el websiteKey (sitekey), el websiteURL, el pageAction de v3 y la función callback de reCAPTCHA en las pestañas Network, Sources y Console de las herramientas de desarrollo, con un script de búsqueda automática.
Source: https://docs.yescaptcha.com/es/guides/find-recaptcha-parameters/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/guides/find-recaptcha-parameters/
Para crear una tarea de reCAPTCHA necesitas `websiteURL` (la dirección de la página donde aparece el captcha) y `websiteKey` (la clave del sitio); v3 además requiere `pageAction`. Si simulas el envío con herramientas como Selenium, también necesitas conocer la función callback. Todo esto se puede encontrar en las herramientas de desarrollo del navegador (F12).
## La forma más rápida: script de búsqueda automática
Abre la página donde aparece el captcha, pulsa F12 para abrir la consola (Console), pega el siguiente código y ejecútalo:
find-recaptcha-clients.js
```js
// Paste into the browser DevTools console on a page with reCAPTCHA, then run findRecaptchaClients().
// Lists every reCAPTCHA on the page: version (V2/V3), sitekey, page URL and the callback function.
function findRecaptchaClients() {
if (typeof ___grecaptcha_cfg === 'undefined') return [];
return Object.entries(___grecaptcha_cfg.clients).map(([cid, client]) => {
const data = { id: cid, version: cid >= 10000 ? 'V3' : 'V2' };
const objects = Object.entries(client).filter(([, value]) => value && typeof value === 'object');
objects.forEach(([toplevelKey, toplevel]) => {
const found = Object.entries(toplevel).find(
([, value]) => value && typeof value === 'object' && 'sitekey' in value && 'size' in value,
);
if (toplevel instanceof HTMLElement && toplevel.tagName === 'DIV') data.pageurl = toplevel.baseURI;
if (found) {
const [sublevelKey, sublevel] = found;
data.sitekey = sublevel.sitekey;
const callbackKey = data.version === 'V2' ? 'callback' : 'promise-callback';
const callback = sublevel[callbackKey];
if (!callback) {
data.callback = null;
data.function = null;
} else {
data.function = callback;
const keys = [cid, toplevelKey, sublevelKey, callbackKey].map((key) => `['${key}']`).join('');
data.callback = `___grecaptcha_cfg.clients${keys}`;
}
}
});
return data;
});
}
findRecaptchaClients();
```
En el resultado, `sitekey` es el `websiteKey`, `pageurl` es el `websiteURL`, `version` indica si es v2 o v3, y `function` y `callback` son la función callback:
```json
[
{
"id": "0",
"version": "V2",
"sitekey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
"function": "onSuccess",
"callback": "___grecaptcha_cfg.clients['0']['l']['l']['callback']",
"pageurl": "https://www.google.com/recaptcha/api2/demo"
}
]
```
Si devuelve un arreglo vacío, la página aún no ha cargado reCAPTCHA; vuelve a ejecutarlo cuando aparezca el captcha.
## websiteKey y websiteURL
En la pestaña Network, busca `anchor` y localiza una solicitud como esta:
```text
https://www.google.com/recaptcha/api2/anchor?ar=1&k=6LfW6wATAAAAAHLqO2pb8bDBahxlMxNdo9g947u9&co=...&hl=en&size=normal
```
- El valor que sigue a `k=` es el `websiteKey`.
- En `websiteURL` va la dirección completa de la página donde aparece el captcha (normalmente es el `Referer` de esta solicitud).
También puedes buscar `data-sitekey` en el código fuente de la página.
## pageAction (v3)
`pageAction` es el `action` que la página pasa al llamar a `grecaptcha.execute(clave del sitio, {action: '...'})`, y debe coincidir con el de la página.
**Método 1: buscar en el código fuente.** En la pestaña Sources de las herramientas de desarrollo, haz clic derecho y elige “Search in all files”. En v3 normal busca `.execute(`; en v3 Enterprise busca `.enterprise.execute`, y mira el `action` que aparece a continuación:
```js
grecaptcha.ready(function () {
grecaptcha.execute('6LdpS-gUAAAAAL3Qr2yP7rkrQjkKBVvEY_48JS5l', { action: 'login' }).then(function (token) {
// ...
});
});
```
Aquí `pageAction` es `login`.
**Método 2: punto de interrupción.** Si el código está ofuscado y la búsqueda no encuentra nada, ejecuta en la consola `debug(grecaptcha.execute)` (en Enterprise, `debug(grecaptcha.enterprise.execute)`) y realiza en la página la acción que dispara la verificación (por ejemplo, hacer clic en iniciar sesión). Cuando el depurador se detenga, mira el valor de `action` en Scope, en el panel de la derecha.
Un sitio puede usar distintos `action` en pasos diferentes (por ejemplo, al registrarse primero `signup/submit_email` y luego `signup/success`); usa el valor del paso que quieres superar. Pulsa F8 para continuar la ejecución y ver el siguiente `action`.
## Función callback
Cuando rellenas el token en el navegador con Selenium u otras herramientas, después debes llamar a la función callback de la página para avisarle de que la verificación ha terminado:
- Busca `data-callback` en la pestaña Elements; su valor es el nombre de la función callback, por ejemplo `data-callback="onSuccess"`.
- O busca `grecaptcha.render` y mira el parámetro `callback`.
- O consulta `___grecaptcha_cfg.clients` en la consola, o usa el script de búsqueda automática de arriba.
Cómo llamarla:
```python
driver.execute_script("onSuccess(arguments[0])", g_recaptcha_response)
```
Algunas páginas no tienen función callback; en ese caso, rellena el token en el cuadro de texto `g-recaptcha-response` y envía el formulario directamente. Para el flujo completo, consulta [Completar reCAPTCHA con un token](https://docs.yescaptcha.com/es/guides/submit-recaptcha-token.md).
---
# Cómo encontrar los parámetros de hCaptcha
> Cómo encontrar el websiteKey (sitekey) de hCaptcha, el websiteURL y el rqdata de la versión Enterprise: busca data-sitekey en el código fuente de la página, o las solicitudes checksiteconfig y getcaptcha en Network.
Source: https://docs.yescaptcha.com/es/guides/find-hcaptcha-parameters/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/guides/find-hcaptcha-parameters/
Para crear una tarea de [hCaptcha](https://docs.yescaptcha.com/es/tasks/hcaptcha.md) necesitas `websiteURL` (la dirección de la página donde aparece el captcha) y `websiteKey` (la clave del sitio, en formato UUID); en la versión Enterprise a veces también hace falta `rqdata`. Todos se pueden encontrar con las herramientas de desarrollo del navegador (F12).
## websiteKey
**Método 1: código fuente de la página.** En el panel Elements pulsa Ctrl+F (Cmd+F en Mac) y busca `data-sitekey`:
```html
```
El valor de `data-sitekey` es el `websiteKey`.
**Método 2: solicitudes de red.** En el panel Network busca `hcaptcha` y localiza la solicitud `checksiteconfig`; el valor que sigue a `sitekey=` en la dirección es el `websiteKey`:
```text
https://api.hcaptcha.com/checksiteconfig?v=...&host=example.com&sitekey=51829642-2cda-4b09-896c-594f89d700cc&sc=1&swa=1
```
## websiteURL
Indica la dirección completa de la página donde aparece el captcha, **no** `hcaptcha.com`. El valor de `host=` en la solicitud anterior es el dominio de esa página.
## rqdata (versión Enterprise)
Algunos sitios usan hCaptcha Enterprise y emiten un `rqdata` cada vez que se carga el captcha; si no lo envías, el token no pasa la validación. Normalmente aparece en la respuesta de la propia API del sitio (por ejemplo, el campo `captcha_rqdata` que devuelve la API de inicio de sesión), o se pasa al llamar a `hcaptcha.render` / `hcaptcha.setData`. Una vez que lo tengas, colócalo en el campo `rqdata` de la tarea. Por lo general, `rqdata` solo se puede usar una vez, así que obtén uno nuevo cada vez.
## userAgent
`userAgent` solo puede ser el valor que devuelve [/useragent](https://docs.yescaptcha.com/es/api/useragent.md); al enviar el token, usa el `userAgent` que viene en el resultado del reconocimiento.
---
# Encontrar los parámetros de Turnstile
> Cómo encontrar el websiteKey (sitekey, empieza por 0x) y el websiteURL de Cloudflare Turnstile: busca data-sitekey o turnstile.render en el código fuente de la página, o revisa las solicitudes a challenges.cloudflare.com en Network.
Source: https://docs.yescaptcha.com/es/guides/find-turnstile-parameters/ · Last verified: 2026-10-21
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/guides/find-turnstile-parameters/
Para crear una tarea de [Turnstile](https://docs.yescaptcha.com/es/tasks/turnstile.md) necesitas `websiteURL` (la dirección de la página donde aparece el cuadro de verificación) y `websiteKey` (la clave del sitio, normalmente empieza por `0x`). Primero confirma que es Turnstile y no la página de verificación de Cloudflare; consulta [Identificar el tipo de captcha](https://docs.yescaptcha.com/es/guides/identify-captcha.md).
## websiteKey
**Método 1: código fuente de la página.** En el panel Elements de las herramientas de desarrollo (F12), busca `data-sitekey`:
```html
```
**Método 2: scripts.** Si el cuadro de verificación se renderiza con JavaScript, haz clic derecho en el panel Sources, elige “Search in all files”, busca `turnstile.render` y revisa el `sitekey` en sus parámetros:
```js
turnstile.render('#container', { sitekey: '0x4AAAAAAAxxxxxxxxxxxxxx', callback: onDone });
```
**Método 3: solicitudes de red.** En el panel Network busca `challenges.cloudflare.com`; la URL del iframe del cuadro de verificación contiene la clave del sitio, que empieza por `0x`.
## websiteURL
Indica la dirección completa de la página donde aparece el cuadro de verificación, por ejemplo `https://example.com/login`.
## action y cData (normalmente no hacen falta)
En la gran mayoría de los casos no se necesitan. Búscalos solo cuando estés seguro de que `websiteKey` y `websiteURL` son correctos y la tarea sigue fallando: revisa en los parámetros de `turnstile.render` o en el elemento del cuadro de verificación si hay `action` y `cData` (en el elemento son `data-action` y `data-cdata`):
```js
turnstile.render('#container', { sitekey: '0x4AAAAAAAxxxxxxxxxxxxxx', action: 'login', cData: 'c0bd4b36-7419-4e18-83c6-378699f2a9a2' });
```
Si existen, al crear la tarea pasa `action` en `pageAction` y `cData` en `data`; consulta [Turnstile](https://docs.yescaptcha.com/es/tasks/turnstile.md).
## Enviar el token
Cuando la tarea termine, coloca el `token` en el campo oculto del formulario llamado `cf-turnstile-response` (si la página usa `turnstile.render` con un `callback`, llama a esa función con el token) y envía el formulario. En la solicitud de envío usa como User-Agent el `userAgent` del resultado.
---
# Usar el token para completar reCAPTCHA
> Qué hacer con el token de reCAPTCHA (gRecaptchaResponse): cómo funciona, enviarlo con una solicitud directa (campo g-recaptcha-response) o rellenarlo en el navegador y llamar al callback, con ejemplos completos en Python sobre la página de demostración de Google.
Source: https://docs.yescaptcha.com/es/guides/submit-recaptcha-token/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/guides/submit-recaptcha-token/
El `gRecaptchaResponse` que devuelve YesCaptcha es el mismo resultado que Google entrega a la página cuando alguien completa el captcha. Una vez que lo tienes, debes **enviarlo al sitio de destino** (no a Google ni a YesCaptcha) igual que lo haría un navegador; el sitio lo verifica con Google y te deja pasar. Hay dos formas: enviar la solicitud directamente, o rellenarlo en la página dentro de un navegador real y enviar el formulario.
## Cómo funciona
El flujo normal es este:
1. La página carga reCAPTCHA y el usuario completa la verificación;
2. Google entrega a la página un token, que la página coloca en el cuadro de texto `g-recaptcha-response` (o pasa a un callback);
3. El usuario envía el formulario y el token viaja con él al servidor del sitio;
4. El servidor del sitio verifica el token con Google y, si es válido, deja pasar.
Con YesCaptcha, nosotros hacemos los pasos 1 y 2: creas una tarea con `websiteURL` y `websiteKey`, obtienes el token y continúas desde el paso 3.
> **Precaución:** El token es de un solo uso y es válido unos 120 segundos; te recomendamos enviarlo en los 60 segundos siguientes a recibirlo. El sitio rechaza los tokens caducados.
## Método 1: enviar la solicitud directamente (recomendado)
1. Haz el proceso una vez a mano en el navegador: abre el panel Network con F12, completa el captcha, envía el formulario y localiza la solicitud que lo envía.
2. En el Payload (o Form Data) de la solicitud, busca el campo que lleva el token, normalmente `g-recaptcha-response`, con un valor que empieza por `03A`. Algunos sitios lo renombran, por ejemplo `grecaptcharesponse` o `captcha`.
3. Envía desde tu programa una solicitud idéntica, cambiando el valor de ese campo por el token que devolvió YesCaptcha. Los demás campos, las cookies y los encabezados también deben coincidir con los del navegador, porque los sitios suelen comprobarlos a la vez.
Ejemplo completo con la página de demostración de Google: primero se resuelve el captcha y luego se envía el token a la página de demostración en el campo `g-recaptcha-response`:
recaptcha_requests.py
```python
"""Solve reCAPTCHA v2 on Google's demo page and submit the token with plain HTTP (no browser).
Run: pip install requests
export YESCAPTCHA_CLIENT_KEY=your_client_key
python recaptcha_requests.py
Each run creates one NoCaptchaTaskProxyless task (charged per the price list).
"""
import os
import time
import requests
CLIENT_KEY = os.environ["YESCAPTCHA_CLIENT_KEY"]
API = "https://api.yescaptcha.com"
WEBSITE_URL = "https://www.google.com/recaptcha/api2/demo"
WEBSITE_KEY = "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"
def call(method, payload):
data = requests.post(f"{API}/{method}", json={"clientKey": CLIENT_KEY, **payload}, timeout=30).json()
if data.get("errorId"):
raise RuntimeError(f"{data.get('errorCode')}: {data.get('errorDescription')}")
return data
def get_token():
task = {"type": "NoCaptchaTaskProxyless", "websiteURL": WEBSITE_URL, "websiteKey": WEBSITE_KEY}
task_id = call("createTask", {"task": task})["taskId"]
for _ in range(36): # poll every 5 seconds, for up to about 3 minutes
time.sleep(5)
result = call("getTaskResult", {"taskId": task_id})
if result.get("status") == "ready":
return result["solution"]["gRecaptchaResponse"]
raise TimeoutError(task_id)
token = get_token()
print("token:", token[:40], "...")
# Submit the token the same way the browser does: the demo form posts the field
# "g-recaptcha-response" back to the page. Check your own site's request in DevTools > Network.
page = requests.post(WEBSITE_URL, data={"g-recaptcha-response": token}, timeout=30)
print("passed" if "Verification Success" in page.text else "not passed", page.status_code)
```
## Método 2: rellenarlo en el navegador (Selenium y similares)
Si controlas un navegador real con herramientas como Selenium o Playwright:
1. Lee `data-sitekey` de la página y úsalo para crear una tarea y obtener un token.
2. Escribe el token en el cuadro de texto `g-recaptcha-response` de la página.
3. Si la página define un callback (`data-callback="..."`), llámalo pasándole el token; en algunos sitios el botón de envío solo se habilita después de llamar al callback.
4. Envía el formulario.
```js
// Step 2: write the token (run in the page)
document.getElementById('g-recaptcha-response').value = 'TOKEN';
// Step 3: call the callback if there is one, e.g. data-callback="onSuccess"
onSuccess('TOKEN');
```
Cuando la página tiene varios reCAPTCHA, el id del cuadro de texto puede ser algo como `g-recaptcha-response-1`. Si no encuentras el cuadro de texto, completa el captcha una vez a mano, busca `03A` en Elements y comprueba dónde se guarda el resultado. Para saber cómo encontrar el callback, consulta [Buscar los parámetros de reCAPTCHA](https://docs.yescaptcha.com/es/guides/find-recaptcha-parameters.md).
Ejemplo completo (Selenium 4):
recaptcha_selenium.py
```python
"""Solve reCAPTCHA v2 on Google's demo page in a real browser with Selenium 4:
get a token from YesCaptcha, put it into the page, then submit the form.
Run: pip install requests selenium
export YESCAPTCHA_CLIENT_KEY=your_client_key
python recaptcha_selenium.py
Each run creates one NoCaptchaTaskProxyless task (charged per the price list).
"""
import os
import time
import requests
from selenium import webdriver
from selenium.webdriver.common.by import By
CLIENT_KEY = os.environ["YESCAPTCHA_CLIENT_KEY"]
API = "https://api.yescaptcha.com"
WEBSITE_URL = "https://www.google.com/recaptcha/api2/demo"
def call(method, payload):
data = requests.post(f"{API}/{method}", json={"clientKey": CLIENT_KEY, **payload}, timeout=30).json()
if data.get("errorId"):
raise RuntimeError(f"{data.get('errorCode')}: {data.get('errorDescription')}")
return data
def get_token(website_url, website_key):
task = {"type": "NoCaptchaTaskProxyless", "websiteURL": website_url, "websiteKey": website_key}
task_id = call("createTask", {"task": task})["taskId"]
for _ in range(36):
time.sleep(5)
result = call("getTaskResult", {"taskId": task_id})
if result.get("status") == "ready":
return result["solution"]["gRecaptchaResponse"]
raise TimeoutError(task_id)
driver = webdriver.Chrome() # Selenium 4 downloads a matching chromedriver automatically
try:
driver.get(WEBSITE_URL)
site_key = driver.find_element(By.CSS_SELECTOR, "[data-sitekey]").get_attribute("data-sitekey")
token = get_token(WEBSITE_URL, site_key)
# Put the token where reCAPTCHA keeps it ...
driver.execute_script(
"document.getElementById('g-recaptcha-response').value = arguments[0];", token
)
# ... and, if the page uses a callback (data-callback="..."), call it:
callback = driver.find_element(By.CSS_SELECTOR, "[data-sitekey]").get_attribute("data-callback")
if callback:
driver.execute_script(f"window[{callback!r}](arguments[0]);", token)
driver.find_element(By.ID, "recaptcha-demo-submit").click()
time.sleep(2)
print("passed" if "Verification Success" in driver.page_source else "not passed")
finally:
driver.quit()
```
## reCAPTCHA v3
v3 no tiene casilla de verificación. La página llama a `grecaptcha.execute(clave del sitio, {action: '...'})` cuando necesita un token y lo incluye en su propia solicitud (el nombre del campo lo decide el sitio; los más comunes son `g-recaptcha-response`, `token` y `recaptchaToken`). Se procede igual que en el Método 1: localiza en Network la solicitud que lleva el token y reprodúcela. Al crear la tarea, `pageAction` debe coincidir con el `action` de la página.
## Lo envié y sigue sin pasar
- El token caducó: envíalo lo antes posible, sin pasar de 60 segundos.
- Enviaste un campo distinto del que comprueba el sitio, o faltan otros campos o cookies: compáralo con la solicitud del navegador campo por campo.
- El sitio también comprueba la IP, el User-Agent, etc.: usa un tipo con proxy propio (como `NoCaptchaTask`) y envía por el mismo proxy.
- Puntuación de v3 insuficiente: confirma `pageAction`, o usa un tipo de puntuación alta fija; consulta [reCAPTCHA v3](https://docs.yescaptcha.com/es/tasks/recaptcha-v3.md).
- El control de riesgos del sitio también mira otras señales de comportamiento. Si la tasa de éxito con tokens es baja, usa [reconocimiento de imágenes](https://docs.yescaptcha.com/es/tasks/recaptcha-classification.md) y haz clic en un navegador real, o usa la [extensión del navegador](https://docs.yescaptcha.com/es/extension.md).
---
# Clics simulados en reCAPTCHA v2 con reconocimiento de imágenes (Selenium)
> Usa Python, Selenium 4 y ReCaptchaV2Classification para hacer clic automáticamente en los desafíos de imágenes de reCAPTCHA v2 en el navegador: activa el captcha, lee la pregunta y las imágenes, llama a la API de reconocimiento, haz clic en las casillas y envía; código de ejemplo completo.
Source: https://docs.yescaptcha.com/es/guides/recaptcha-click-selenium/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/guides/recaptcha-click-selenium/
Este tutorial abre la página de demostración de reCAPTCHA de Google con Selenium 4 y resuelve el desafío de imágenes en un navegador real: lee la pregunta y la imagen, se las envía a [reconocimiento de imágenes de reCAPTCHA v2](https://docs.yescaptcha.com/es/tasks/recaptcha-classification.md) (`ReCaptchaV2Classification`) para saber en qué casillas hacer clic, y luego simula los clics. A diferencia del enfoque con token, la verificación se completa en el propio navegador, lo que es útil en sitios donde los tokens rara vez pasan.
Si no quieres escribir código, usa directamente la [extensión del navegador](https://docs.yescaptcha.com/es/extension.md), que hace lo mismo con la misma API.
## Preparación
```bash
pip install requests selenium pillow
export YESCAPTCHA_CLIENT_KEY=your_client_key
```
Necesitas tener Chrome instalado. Selenium 4 descarga automáticamente el chromedriver compatible.
## Flujo
1. **Haz clic en la casilla.** La casilla está dentro del iframe con `title="reCAPTCHA"`: cambia a ese iframe y haz clic en `#recaptcha-anchor`.
2. **Cambia al iframe del desafío.** El desafío está en otro iframe (cuyo title contiene “challenge”).
3. **Lee la pregunta.** El texto en negrita de `.rc-imageselect-desc-wrapper strong` es el objetivo, por ejemplo “traffic lights”. La API necesita el ID de la pregunta, así que usa la tabla de equivalencias para convertir el nombre en un ID (`/m/015qff`); consulta [ID de pregunta](https://docs.yescaptcha.com/es/tasks/recaptcha-classification.md). Es más fácil comparar si la interfaz del navegador está en inglés.
4. **Obtén la imagen.** Las casillas son en realidad fragmentos de una misma imagen grande: descarga el `src` de `td.rc-imageselect-tile img`. Con 9 casillas (3x3) escálala a 300×300 y con 16 casillas (4x4) a 450×450, y conviértela a Base64.
5. **Reconoce.** Llama a `createTask` con el tipo `ReCaptchaV2Classification` y envía `image` y `question`. Si añades `"confidence": 0.5`, las imágenes 3x3 devuelven de una vez todas las casillas que coinciden, y no tienes que gestionar las imágenes pequeñas que aparecen tras hacer clic.
6. **Haz clic.** `objects` contiene los índices de las casillas, empezando en 0, de izquierda a derecha y de arriba abajo; haz clic en los `td` correspondientes en ese orden.
7. **Verifica.** Haz clic en `#recaptcha-verify-button`. Si aparece una nueva ronda, vuelve al paso 3; cuando la ventana del desafío se cierra, has pasado.
8. **Envía el formulario.** Vuelve a la página principal y haz clic en el botón de envío.
## Código completo
recaptcha_click_selenium.py
```python
"""Click through a reCAPTCHA v2 image challenge with Selenium 4 and ReCaptchaV2Classification.
Flow: open the page -> click the checkbox -> read the target name and the grid image ->
ask YesCaptcha which tiles to click -> click them -> press Verify. Repeat if a new challenge appears.
Run: pip install requests selenium pillow
export YESCAPTCHA_CLIENT_KEY=your_client_key
python recaptcha_click_selenium.py
Each recognized image is charged (see the price list). reCAPTCHA's page structure can change;
adjust the selectors below if a step stops working.
"""
import base64
import io
import os
import time
import requests
from PIL import Image
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.wait import WebDriverWait
CLIENT_KEY = os.environ["YESCAPTCHA_CLIENT_KEY"]
PAGE_URL = "https://www.google.com/recaptcha/api2/demo"
# Target names shown in the challenge (English UI) -> question IDs.
# Full list: https://docs.yescaptcha.com/en/tasks/recaptcha-classification/
QUESTION_IDS = {
"taxis": "/m/0pg52", "bus": "/m/01bjv", "buses": "/m/01bjv", "motorcycles": "/m/04_sv",
"tractors": "/m/013xlm", "chimneys": "/m/01jk_4", "crosswalks": "/m/014xcs",
"traffic lights": "/m/015qff", "bicycles": "/m/0199g", "parking meters": "/m/015qbp",
"cars": "/m/0k4j", "bridges": "/m/015kr", "boats": "/m/019jd", "palm trees": "/m/0cdl1",
"mountains or hills": "/m/09d_r", "fire hydrants": "/m/01pns0", "a fire hydrant": "/m/01pns0",
"stairs": "/m/01lynh",
}
def classify(image_b64, question):
task = {"type": "ReCaptchaV2Classification", "image": image_b64, "question": question, "confidence": 0.5}
data = requests.post(
"https://api.yescaptcha.com/createTask",
json={"clientKey": CLIENT_KEY, "task": task},
timeout=30,
).json()
if data.get("errorId"):
raise RuntimeError(f"{data.get('errorCode')}: {data.get('errorDescription')}")
return data["solution"] # synchronous: the solution comes back right away
def grid_image_b64(url, size):
"""Download the challenge image and scale it to the standard size (300 for 3x3, 450 for 4x4)."""
img = Image.open(io.BytesIO(requests.get(url, timeout=30).content)).convert("RGB")
img = img.resize((size, size))
buf = io.BytesIO()
img.save(buf, format="JPEG")
return base64.b64encode(buf.getvalue()).decode()
driver = webdriver.Chrome()
wait = WebDriverWait(driver, 15)
try:
driver.get(PAGE_URL)
# 1. Click the checkbox (inside the "reCAPTCHA" iframe)
wait.until(EC.frame_to_be_available_and_switch_to_it((By.CSS_SELECTOR, 'iframe[title="reCAPTCHA"]')))
wait.until(EC.element_to_be_clickable((By.ID, "recaptcha-anchor"))).click()
driver.switch_to.default_content()
# 2. Switch to the challenge iframe and solve rounds until it closes
wait.until(EC.frame_to_be_available_and_switch_to_it(
(By.XPATH, '//iframe[contains(@title, "challenge")]')))
for _ in range(5):
target = wait.until(EC.presence_of_element_located(
(By.CSS_SELECTOR, ".rc-imageselect-desc-wrapper strong"))).text.strip().lower()
question = QUESTION_IDS.get(target)
if not question:
print("unsupported target, reloading:", target)
driver.find_element(By.ID, "recaptcha-reload-button").click()
time.sleep(2)
continue
tiles = driver.find_elements(By.CSS_SELECTOR, "td.rc-imageselect-tile")
size = 450 if len(tiles) == 16 else 300
url = driver.find_element(By.CSS_SELECTOR, "td.rc-imageselect-tile img").get_attribute("src")
solution = classify(grid_image_b64(url, size), question)
for index in solution.get("objects", []):
tiles[index].click()
time.sleep(0.3)
time.sleep(1)
driver.find_element(By.ID, "recaptcha-verify-button").click()
time.sleep(3)
driver.switch_to.default_content()
frame = driver.find_element(By.XPATH, '//iframe[contains(@title, "challenge")]')
if not frame.is_displayed(): # challenge closed: passed
break
driver.switch_to.frame(frame)
driver.switch_to.default_content()
driver.find_element(By.ID, "recaptcha-demo-submit").click()
time.sleep(2)
print("passed" if "Verification Success" in driver.page_source else "not passed")
finally:
driver.quit()
```
## Notas
- La estructura de la página de reCAPTCHA cambia con el tiempo; si los selectores del código dejan de funcionar, ajústalos a la página real.
- Cada imagen reconocida implica un cobro de puntos (precios en [reconocimiento de imágenes de reCAPTCHA v2](https://docs.yescaptcha.com/es/tasks/recaptcha-classification.md)). Las tareas cuyo clic fue rechazado se pueden [reportar](https://docs.yescaptcha.com/es/api/report.md) en un plazo de 1 hora para solicitar el reembolso tras reportar.
- Si encuentras una pregunta que no está en la tabla de equivalencias, haz clic en el botón de recarga para obtener otra, o contacta con Soporte para que añadan compatibilidad.
---
# Clic en imágenes de hCaptcha con Selenium
> Usa Python, Selenium 4 y HCaptchaClassification para resolver en un navegador real las cuadrículas 3×3 de hCaptcha: haz clic en la casilla, lee la pregunta y las 9 imágenes, llama a la API, haz clic y envía; código de ejemplo completo.
Source: https://docs.yescaptcha.com/es/guides/hcaptcha-click-selenium/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/guides/hcaptcha-click-selenium/
Este tutorial abre la página de demostración de hCaptcha con Selenium 4 y resuelve la cuadrícula 3×3 en un navegador real: lee la pregunta y las 9 imágenes, consulta a [reconocimiento de imágenes de hCaptcha](https://docs.yescaptcha.com/es/tasks/hcaptcha-classification.md) (`HCaptchaClassification`) cuáles son el objetivo y simula los clics.
hCaptcha también tiene preguntas de hacer clic en una posición y de arrastrar, que devuelven coordenadas en lugar de celdas; consulta [reconocimiento de imágenes de hCaptcha](https://docs.yescaptcha.com/es/tasks/hcaptcha-classification.md). Si no quieres escribir código, la [extensión del navegador](https://docs.yescaptcha.com/es/extension.md) las resuelve todas.
## Preparación
```bash
pip install requests selenium
export YESCAPTCHA_CLIENT_KEY=your_client_key
```
## Pasos
1. **Haz clic en la casilla.** Está dentro del iframe de hCaptcha cuya URL contiene `frame=checkbox`; cambia a ese iframe y haz clic en `#checkbox`.
2. **Cambia al iframe de la pregunta.** Su URL contiene `frame=challenge`.
3. **Lee la pregunta.** El texto de `.prompt-text` es la pregunta; envíala tal cual a la API (se recomienda cambiar el idioma de la interfaz de hCaptcha a inglés o chino simplificado). Si junto a la pregunta aparecen imágenes de ejemplo, inclúyelas también en `anchors`.
4. **Obtén las imágenes.** La imagen de fondo de `.task-image .image` de cada celda es una imagen; descárgalas en orden, conviértelas a Base64 y arma la lista `queries`.
5. **Reconoce.** Llama a `createTask` con el tipo `HCaptchaClassification`. Los elementos de `objects` corresponden uno a uno con las celdas; `true` indica que es objetivo.
6. **Haz clic y envía.** Haz clic en las celdas objetivo y pulsa el botón de enviar. Pueden seguir varias rondas; repite los pasos 3 a 6.
7. **Listo.** Tras pasar la verificación, el campo `h-captcha-response` de la página contiene el token, que se envía junto con el formulario.
## Código completo
hcaptcha_click_selenium.py
```python
"""Click through an hCaptcha 3x3 image challenge with Selenium 4 and HCaptchaClassification.
Flow: open the page -> click the checkbox -> read the question and the 9 images ->
ask YesCaptcha which images match -> click them -> submit. Repeat while new rounds appear.
Run: pip install requests selenium
export YESCAPTCHA_CLIENT_KEY=your_client_key
python hcaptcha_click_selenium.py
Each recognized round is charged (see the price list; rounds with no target found are free).
hCaptcha changes its page structure often; adjust the selectors below if a step stops working.
Click and drag questions return coordinates instead; see the HCaptchaClassification page.
"""
import base64
import os
import re
import time
import requests
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.wait import WebDriverWait
CLIENT_KEY = os.environ["YESCAPTCHA_CLIENT_KEY"]
PAGE_URL = "https://accounts.hcaptcha.com/demo"
def classify(question, images_b64):
task = {"type": "HCaptchaClassification", "question": question, "queries": images_b64}
data = requests.post(
"https://api.yescaptcha.com/createTask",
json={"clientKey": CLIENT_KEY, "task": task},
timeout=60,
).json()
if data.get("errorId"):
raise RuntimeError(f"{data.get('errorCode')}: {data.get('errorDescription')}")
return data["solution"] # synchronous
def background_image_b64(element):
"""The tiles are s with a CSS background image; download it and Base64-encode it."""
style = element.get_attribute("style") or ""
match = re.search(r'url\("?(.*?)"?\)', style)
if not match:
return None
return base64.b64encode(requests.get(match.group(1), timeout=30).content).decode()
driver = webdriver.Chrome()
wait = WebDriverWait(driver, 15)
try:
driver.get(PAGE_URL)
# 1. Click the checkbox (inside the first hCaptcha iframe)
wait.until(EC.frame_to_be_available_and_switch_to_it(
(By.CSS_SELECTOR, 'iframe[src*="hcaptcha"][src*="frame=checkbox"]')))
wait.until(EC.element_to_be_clickable((By.ID, "checkbox"))).click()
driver.switch_to.default_content()
# 2. Solve rounds in the challenge iframe
wait.until(EC.frame_to_be_available_and_switch_to_it(
(By.CSS_SELECTOR, 'iframe[src*="hcaptcha"][src*="frame=challenge"]')))
for _ in range(5):
question = wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, ".prompt-text"))).text.strip()
tiles = driver.find_elements(By.CSS_SELECTOR, ".task-image")
images = [background_image_b64(t.find_element(By.CSS_SELECTOR, ".image")) for t in tiles]
if not tiles or None in images:
print("not a 3x3 image challenge; see the docs for click/drag questions")
break
solution = classify(question, images)
for tile, hit in zip(tiles, solution.get("objects", [])):
if hit:
tile.click()
time.sleep(0.3)
driver.find_element(By.CSS_SELECTOR, ".button-submit").click()
time.sleep(3)
if not driver.find_elements(By.CSS_SELECTOR, ".task-image"):
break
driver.switch_to.default_content()
token = driver.find_element(By.NAME, "h-captcha-response").get_attribute("value")
print("token received" if token else "not passed")
finally:
driver.quit()
```
## Notas
- hCaptcha cambia a menudo la estructura de su página; si los selectores del código dejan de funcionar, ajústalos según la página real.
- Cada ronda reconocida implica un cobro de puntos; las rondas en las que no se encuentra ningún objetivo no se cobran. Si la verificación falla tras los clics, puedes [reportarlo](https://docs.yescaptcha.com/es/api/report.md) en el plazo de 1 hora para solicitar un reembolso tras reportar.
- Si una pregunta nueva devuelve `ERROR_UNKNOWN_QUESTION`, actualiza para obtener otra o contacta con soporte.
---
# Código de ejemplo y SDK
> Código de ejemplo ejecutable de YesCaptcha (Python, Node.js, curl, C#, Easy Language) y SDK no oficiales de la comunidad (Python, Node.js, Go).
Source: https://docs.yescaptcha.com/es/samples/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/samples/
Los ejemplos de esta página son archivos completos que puedes ejecutar directamente; leen el ClientKey de la variable de entorno `YESCAPTCHA_CLIENT_KEY`. Cada página de tipo de tarea también incluye ejemplos de curl, Python y Node.js generados para ese tipo.
[Python](https://docs.yescaptcha.com/es/samples/python.md)Consulta de saldo, primera solicitud, cliente reutilizable, control de tareas simultáneas, Selenium
[Node.js](https://docs.yescaptcha.com/es/samples/nodejs.md)Node.js 18+, sin librerías de terceros
[C#](https://docs.yescaptcha.com/es/samples/csharp.md).NET 6+
[Easy Language](https://docs.yescaptcha.com/es/samples/easy-language.md)Ejemplos de clics simulados aportados por usuarios
Para probar solo desde la línea de comandos, consulta los ejemplos de curl en [Inicio rápido](https://docs.yescaptcha.com/es/getting-started/quickstart.md) y [getBalance](https://docs.yescaptcha.com/es/api/get-balance.md).
## SDK de la comunidad
Los siguientes SDK los aportan usuarios y **no son oficiales**. No hemos revisado su código; evalúalos por tu cuenta antes de usarlos y, si tienes problemas, contacta con sus autores:
| Lenguaje | Proyecto |
| --- | --- |
| Python | [github.com/yescaptcha/yescaptcha-python](https://github.com/yescaptcha/yescaptcha-python) |
| Node.js | [github.com/ScoLib/yescaptcha](https://github.com/ScoLib/yescaptcha) |
| Go | [github.com/FreedWu/yescaptcha](https://github.com/FreedWu/yescaptcha) |
| Go | [github.com/deanxv/yescaptcha-go](https://github.com/deanxv/yescaptcha-go) |
Con cualquier SDK, comprueba que use como dirección de la API `api.yescaptcha.com` o `cn.yescaptcha.com`, y que los nombres de los tipos de tarea coincidan con los de este sitio.
---
# Python
> Ejemplos de YesCaptcha en Python: consultar el saldo, resolver un captcha de imagen, una clase de cliente reutilizable (crea la tarea y consulta cada 5 segundos), control de tareas simultáneas con asyncio y envío de reCAPTCHA con requests y Selenium.
Source: https://docs.yescaptcha.com/es/samples/python/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/samples/python/
Requisitos: Python 3.8 o superior y `pip install requests`. Antes de ejecutar, define la variable de entorno:
```bash
export YESCAPTCHA_CLIENT_KEY=your_client_key
```
## Consultar el saldo
No cobra puntos; sirve para confirmar que el ClientKey es correcto:
get_balance.py
```python
"""Check the balance. getBalance is free and is a quick way to verify your clientKey."""
import os
import requests
CLIENT_KEY = os.environ["YESCAPTCHA_CLIENT_KEY"]
r = requests.post(
"https://api.yescaptcha.com/getBalance",
json={"clientKey": CLIENT_KEY},
timeout=30,
)
data = r.json()
if data.get("errorId"):
# e.g. ERROR_KEY_DOES_NOT_EXIST when the clientKey is wrong
print("error:", data.get("errorCode"), data.get("errorDescription"))
else:
print("balance (points):", data["balance"])
```
## Resolver un captcha de imagen
El tipo síncrono `ImageToTextTaskOcrBase` devuelve el resultado en una sola solicitud. Imagen de ejemplo: [captcha.jpg](https://docs.yescaptcha.com/samples/captcha.jpg).
quickstart.py
```python
"""First request: read an alphanumeric image captcha with ImageToTextTaskOcrBase
(synchronous, 2 points per image).
Usage:
export YESCAPTCHA_CLIENT_KEY=your_client_key
python quickstart.py captcha.png
"""
import base64
import os
import sys
import requests
CLIENT_KEY = os.environ["YESCAPTCHA_CLIENT_KEY"]
image_path = sys.argv[1] if len(sys.argv) > 1 else "captcha.png"
with open(image_path, "rb") as f:
body = base64.b64encode(f.read()).decode() # no "data:" prefix
r = requests.post(
"https://api.yescaptcha.com/createTask",
json={
"clientKey": CLIENT_KEY,
"task": {"type": "ImageToTextTaskOcrBase", "body": body},
},
timeout=30,
)
data = r.json()
if data.get("errorId"):
raise SystemExit(f"{data.get('errorCode')}: {data.get('errorDescription')}")
print("text:", data["solution"]["text"])
```
## Un cliente reutilizable
Copia el siguiente archivo en tu proyecto; funciona con tipos síncronos y asíncronos:
yescaptcha.py
```python
"""A small client you can copy into your project: create tasks, poll results, check the balance.
from yescaptcha import YesCaptcha
client = YesCaptcha(os.environ["YESCAPTCHA_CLIENT_KEY"])
solution = client.solve({
"type": "NoCaptchaTaskProxyless",
"websiteURL": "https://www.google.com/recaptcha/api2/demo",
"websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
})
print(solution["gRecaptchaResponse"])
"""
import os
import time
import requests
class YesCaptchaError(Exception):
def __init__(self, code, description):
super().__init__(f"{code}: {description}")
self.code = code
self.description = description
class YesCaptcha:
def __init__(self, client_key, endpoint="https://api.yescaptcha.com", poll_interval=5, timeout=180):
self.client_key = client_key
self.endpoint = endpoint.rstrip("/")
self.poll_interval = poll_interval # 5 s: polling the same taskId more often only returns "processing"
self.timeout = timeout
self.session = requests.Session()
def call(self, method, payload=None):
body = {"clientKey": self.client_key, **(payload or {})}
data = self.session.post(f"{self.endpoint}/{method}", json=body, timeout=30).json()
if data.get("errorId"):
raise YesCaptchaError(data.get("errorCode"), data.get("errorDescription"))
return data
def balance(self):
return self.call("getBalance")["balance"]
def solve(self, task):
created = self.call("createTask", {"task": task})
if created.get("status") == "ready": # synchronous types return the solution directly
return created["solution"]
task_id = created["taskId"]
deadline = time.time() + self.timeout
while time.time() < deadline:
time.sleep(self.poll_interval)
result = self.call("getTaskResult", {"taskId": task_id})
if result.get("status") == "ready":
return result["solution"]
raise TimeoutError(f"task {task_id} not ready after {self.timeout}s")
if __name__ == "__main__":
client = YesCaptcha(os.environ["YESCAPTCHA_CLIENT_KEY"])
print("balance:", client.balance())
```
```python
from yescaptcha import YesCaptcha
client = YesCaptcha(os.environ["YESCAPTCHA_CLIENT_KEY"])
solution = client.solve({
"type": "HCaptchaTaskProxyless",
"websiteURL": "https://accounts.hcaptcha.com/demo",
"websiteKey": "a5f74b19-9e45-40e0-b45d-47ff91b7a6c2",
})
print(solution["gRecaptchaResponse"])
```
Si hay un error, se lanza `YesCaptchaError`; `e.code` es el código de error (consulta [Códigos de error](https://docs.yescaptcha.com/es/api/errors.md)).
## Controlar las tareas simultáneas
Al enviar tareas en lote, limita cuántas solicitudes se procesan al mismo tiempo y, si recibes `ERROR_THREADS_MAXIMUM`, espera un momento y vuelve a intentarlo (requiere `pip install aiohttp`). Más información en [Límite de tareas simultáneas y pausa automática](https://docs.yescaptcha.com/es/api/rate-limits.md):
concurrency.py
```python
"""Limit concurrency: keep the number of requests waiting for a result below your limit, and back off
on ERROR_THREADS_MAXIMUM (rejected requests are not charged). Requires: pip install aiohttp"""
import asyncio
import os
import aiohttp
CLIENT_KEY = os.environ["YESCAPTCHA_CLIENT_KEY"]
LIMIT = 15 # below your concurrency limit
sem = asyncio.Semaphore(LIMIT)
async def solve(session, task):
async with sem: # at most LIMIT requests in progress at a time
result = {}
for attempt in range(5):
async with session.post(
"https://api.yescaptcha.com/createTask",
json={"clientKey": CLIENT_KEY, "task": task},
) as resp:
result = await resp.json()
if result.get("errorCode") != "ERROR_THREADS_MAXIMUM":
return result
await asyncio.sleep(1 + attempt) # over the limit: wait and retry
return result
async def main(tasks):
async with aiohttp.ClientSession() as session:
return await asyncio.gather(*(solve(session, t) for t in tasks))
if __name__ == "__main__":
print(asyncio.run(main([])))
```
## Enviar un token de reCAPTCHA
- Enviarlo directamente con requests: consulta [Completar reCAPTCHA con un token](https://docs.yescaptcha.com/es/guides/submit-recaptcha-token.md)
- Rellenarlo en el navegador con Selenium: consulta [Completar reCAPTCHA con un token](https://docs.yescaptcha.com/es/guides/submit-recaptcha-token.md)
- Simular clics en las preguntas de imágenes con Selenium: consulta [Clics simulados en reCAPTCHA v2 de reconocimiento de imágenes](https://docs.yescaptcha.com/es/guides/recaptcha-click-selenium.md), [Clics simulados en hCaptcha de reconocimiento de imágenes](https://docs.yescaptcha.com/es/guides/hcaptcha-click-selenium.md)
---
# Node.js
> Ejemplos de YesCaptcha en Node.js (Node.js 18+ con el fetch integrado, sin dependencias). Consulta el saldo, resuelve un captcha de imagen y usa una clase de cliente reutilizable (crea la tarea y consulta el resultado cada 5 segundos).
Source: https://docs.yescaptcha.com/es/samples/nodejs/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/samples/nodejs/
Requisitos: Node.js 18 o superior (con `fetch` integrado). Los ejemplos son módulos ES (`.mjs`) y no necesitan dependencias. Antes de ejecutarlos, define la variable de entorno:
```bash
export YESCAPTCHA_CLIENT_KEY=your_client_key
```
## Consultar el saldo
No cobra puntos; sirve para confirmar que el ClientKey es correcto:
get-balance.mjs
```js
// Check the balance. getBalance is free and is a quick way to verify your clientKey. Node.js 18+
const CLIENT_KEY = process.env.YESCAPTCHA_CLIENT_KEY;
const res = await fetch('https://api.yescaptcha.com/getBalance', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ clientKey: CLIENT_KEY }),
});
const data = await res.json();
if (data.errorId) {
// e.g. ERROR_KEY_DOES_NOT_EXIST when the clientKey is wrong
console.log('error:', data.errorCode, data.errorDescription);
} else {
console.log('balance (points):', data.balance);
}
```
## Resolver un captcha de imagen
El tipo síncrono `ImageToTextTaskOcrBase` devuelve el resultado en una sola solicitud. Imagen de ejemplo: [captcha.jpg](https://docs.yescaptcha.com/samples/captcha.jpg). Ejecuta `node quickstart.mjs captcha.jpg`.
quickstart.mjs
```js
// First request: read an alphanumeric image captcha with ImageToTextTaskOcrBase (synchronous, 2 points per image).
// Usage: YESCAPTCHA_CLIENT_KEY=your_client_key node quickstart.mjs captcha.png
import { readFileSync } from 'node:fs';
const CLIENT_KEY = process.env.YESCAPTCHA_CLIENT_KEY;
const body = readFileSync(process.argv[2] ?? 'captcha.png').toString('base64'); // no "data:" prefix
const res = await fetch('https://api.yescaptcha.com/createTask', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ clientKey: CLIENT_KEY, task: { type: 'ImageToTextTaskOcrBase', body } }),
});
const data = await res.json();
if (data.errorId) throw new Error(`${data.errorCode}: ${data.errorDescription}`);
console.log('text:', data.solution.text);
```
## Un cliente reutilizable
yescaptcha.mjs
```js
// A small client you can copy into your project: create tasks, poll results, check the balance. Node.js 18+
//
// import { YesCaptcha } from './yescaptcha.mjs';
// const client = new YesCaptcha(process.env.YESCAPTCHA_CLIENT_KEY);
// const solution = await client.solve({ type: 'NoCaptchaTaskProxyless', websiteURL: '...', websiteKey: '...' });
export class YesCaptchaError extends Error {
constructor(code, description) {
super(`${code}: ${description}`);
this.code = code;
}
}
export class YesCaptcha {
constructor(clientKey, { endpoint = 'https://api.yescaptcha.com', pollInterval = 5000, timeout = 180000 } = {}) {
this.clientKey = clientKey;
this.endpoint = endpoint.replace(/\/$/, '');
this.pollInterval = pollInterval; // 5 s: polling the same taskId more often only returns "processing"
this.timeout = timeout;
}
async call(method, payload = {}) {
const res = await fetch(`${this.endpoint}/${method}`, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ clientKey: this.clientKey, ...payload }),
});
const data = await res.json();
if (data.errorId) throw new YesCaptchaError(data.errorCode, data.errorDescription);
return data;
}
async balance() {
return (await this.call('getBalance')).balance;
}
async solve(task) {
const created = await this.call('createTask', { task });
if (created.status === 'ready') return created.solution; // synchronous types return the solution directly
const deadline = Date.now() + this.timeout;
while (Date.now() < deadline) {
await new Promise((r) => setTimeout(r, this.pollInterval));
const result = await this.call('getTaskResult', { taskId: created.taskId });
if (result.status === 'ready') return result.solution;
}
throw new Error(`task ${created.taskId} not ready after ${this.timeout} ms`);
}
}
if (import.meta.url === `file://${process.argv[1]}`) {
const client = new YesCaptcha(process.env.YESCAPTCHA_CLIENT_KEY);
console.log('balance:', await client.balance());
}
```
```js
import { YesCaptcha } from './yescaptcha.mjs';
const client = new YesCaptcha(process.env.YESCAPTCHA_CLIENT_KEY);
const solution = await client.solve({
type: 'TurnstileTaskProxyless',
websiteURL: 'https://example.com/login',
websiteKey: '0x4AAAAAAA_SITE_KEY',
});
console.log(solution.token);
```
Si hay un error, se lanza `YesCaptchaError`; `err.code` es el código de error (consulta [Códigos de error](https://docs.yescaptcha.com/es/api/errors.md)).
---
# C#
> Ejemplo de YesCaptcha en C# (.NET 6+, HttpClient y System.Text.Json). Consulta el saldo, crea una tarea de reCAPTCHA v2 y consulta el resultado cada 5 segundos.
Source: https://docs.yescaptcha.com/es/samples/csharp/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/samples/csharp/
Requisitos: .NET 6 o superior, solo la biblioteca estándar (`HttpClient`, `System.Text.Json`).
```bash
dotnet new console -o YesCaptchaDemo
cd YesCaptchaDemo
# replace Program.cs with the code below
export YESCAPTCHA_CLIENT_KEY=your_client_key
dotnet run
```
Program.cs
```csharp
// YesCaptcha C# sample (.NET 6+): check the balance, then solve a reCAPTCHA v2.
// Run: dotnet new console -o YesCaptchaDemo, replace Program.cs with this file, set YESCAPTCHA_CLIENT_KEY, then dotnet run
using System;
using System.Net.Http;
using System.Net.Http.Json;
using System.Text.Json;
using System.Text.Json.Nodes;
using System.Threading.Tasks;
class Program
{
const string Api = "https://api.yescaptcha.com";
static readonly HttpClient Http = new HttpClient { Timeout = TimeSpan.FromSeconds(30) };
static readonly string ClientKey = Environment.GetEnvironmentVariable("YESCAPTCHA_CLIENT_KEY") ?? "";
static async Task Call(string method, JsonObject payload)
{
payload["clientKey"] = ClientKey;
var res = await Http.PostAsJsonAsync($"{Api}/{method}", payload);
var data = JsonNode.Parse(await res.Content.ReadAsStringAsync())!;
if ((int?)data["errorId"] != 0)
throw new Exception($"{data["errorCode"]}: {data["errorDescription"]}");
return data;
}
static async Task Solve(JsonObject task)
{
var created = await Call("createTask", new JsonObject { ["task"] = task });
if ((string?)created["status"] == "ready") return created["solution"]!; // synchronous types
var taskId = (string)created["taskId"]!;
for (var i = 0; i < 36; i++) // poll every 5 seconds, for up to about 3 minutes
{
await Task.Delay(5000);
var result = await Call("getTaskResult", new JsonObject { ["taskId"] = taskId });
if ((string?)result["status"] == "ready") return result["solution"]!;
}
throw new TimeoutException(taskId);
}
static async Task Main()
{
var balance = await Call("getBalance", new JsonObject());
Console.WriteLine($"balance (points): {balance["balance"]}");
var solution = await Solve(new JsonObject
{
["type"] = "NoCaptchaTaskProxyless",
["websiteURL"] = "https://www.google.com/recaptcha/api2/demo",
["websiteKey"] = "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
});
Console.WriteLine(solution["gRecaptchaResponse"]);
}
}
```
Para usar otros tipos de tarea, cambia solo el objeto de tarea que se pasa a `Solve`; los campos están en la página de cada [tipo de tarea](https://docs.yescaptcha.com/es/tasks.md). Los tipos síncronos (reconocimiento de imágenes, `ImageToTextTaskOcrBase`) devuelven el resultado directamente en `createTask`, y `Solve` ya lo gestiona.
---
# Easy Language (易语言)
> Ejemplos de YesCaptcha en Easy Language (易语言) aportados por usuarios. Clics en reCAPTCHA y hCaptcha, reconocimiento de imágenes de FunCaptcha y envío de token de reCAPTCHA; descargas y puntos clave para llamar a la API.
Source: https://docs.yescaptcha.com/es/samples/easy-language/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/samples/easy-language/
Easy Language (易语言) es un lenguaje de programación en chino muy popular en China. Estos ejemplos fueron aportados por usuarios (南方填表, 松 y otros) y son solo de referencia; no los hemos revisado línea por línea. Incluyen:
- Clics en reCAPTCHA y hCaptcha (abre el navegador y luego reconoce y hace clic automáticamente)
- Reconocimiento de imágenes de FunCaptcha
- Envío de token de reCAPTCHA
> **Descargas:** Los paquetes de ejemplo (el más grande pesa unos 87 MB e incluye un navegador) se están migrando a una nueva ubicación de descarga. Mientras tanto, [contacta con soporte](https://docs.yescaptcha.com/es/help/contact.md) para obtenerlos.
## Cómo llamar a la API desde Easy Language
No necesitas los paquetes para llamar a la API; basta con el comando de acceso web (POST) de Easy Language:
1. URL `https://api.yescaptcha.com/createTask`, método `POST`, con el encabezado `Content-Type: application/json`.
2. El cuerpo es texto JSON, por ejemplo `{"clientKey":"YOUR_CLIENT_KEY","task":{"type":"ImageToTextTaskOcrBase","body":"BASE64_IMAGE"}}`.
3. Si `errorId` es 0 en el JSON de respuesta, la solicitud fue correcta. En los tipos asíncronos, toma el `taskId` y envía `{"clientKey":"…","taskId":"…"}` a `https://api.yescaptcha.com/getTaskResult` cada 5 segundos hasta que `status` sea `ready`.
4. El Base64 de la imagen no debe incluir el prefijo `data:image/...;base64,` ni saltos de línea.
Consulta el formato de solicitud y respuesta en [Solicitudes y respuestas](https://docs.yescaptcha.com/es/api/overview.md).
## Si un ejemplo no funciona
- Aparece “no se puede crear el navegador”: usa el navegador incluido en el paquete de ejemplo, desinstala otros navegadores que puedan entrar en conflicto o compila el programa antes de ejecutarlo.
- Se devuelve un código de error: revisa los parámetros con la lista de [Códigos de error](https://docs.yescaptcha.com/es/api/errors.md).
---
# Varios ClientKey: límites de gasto, lista blanca de IP y vencimiento
> Una cuenta de YesCaptcha puede tener hasta 20 ClientKey, todas con cargo al mismo saldo de la cuenta. Cada una puede tener su propio límite de gasto (diario, semanal, mensual o total único, con reinicio en hora de Beijing), lista blanca de IP y vencimiento, con efecto en pocos segundos.
Source: https://docs.yescaptcha.com/es/account/client-keys/ · Last verified: 2026-10-29
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/account/client-keys/
Una cuenta de YesCaptcha puede tener hasta 20 `clientKey` (incluida la original), que se administran en la página «Claves y seguridad» del panel de [yescaptcha.com](https://yescaptcha.com/security). Cada `clientKey` puede crear tareas y consultar el saldo, y todas descuentan del mismo saldo de la cuenta. Cada una puede tener su propio límite de gasto, lista blanca de IP y vencimiento, y los cambios surten efecto en pocos segundos.
Casos de uso habituales: separar los entornos de prueba y producción o los distintos proyectos; entregar claves a tus clientes o socios, cada uno con su propio límite; y, si una `clientKey` se filtra, eliminar solo esa sin afectar a los demás programas.
## Key principal y SubKey
| | Key principal | SubKey |
| --- | --- | --- |
| Qué es | La `clientKey` original; una por cuenta | Las que se crean además de la Key principal; hasta 19 |
| Límite, lista blanca de IP, vencimiento | Se pueden configurar | Se pueden configurar |
| Restablecer | Sí: la anterior deja de funcionar de inmediato y el saldo pasa a la nueva | No se puede; elimínala y crea otra |
| Eliminar | No | Sí: deja de funcionar en pocos segundos y no se puede recuperar |
- Todas tienen el mismo formato: los primeros 40 caracteres son la clave y después va tu ID de usuario.
- Restablecer la Key principal no afecta a las SubKey.
- Uses la `clientKey` que uses para crear tareas o consultar el saldo, la API y las respuestas son iguales; la única diferencia son las comprobaciones adicionales de límite, lista blanca de IP y vencimiento.
## Crear una clientKey
1. Inicia sesión en [yescaptcha.com](https://yescaptcha.com/) y abre la página «Claves y seguridad» ([yescaptcha.com/security](https://yescaptcha.com/security)).
2. En «Todas las Keys», haz clic en «Nueva subKey». El nombre (hasta 40 caracteres), el límite, la lista blanca de IP y el vencimiento son opcionales y se pueden cambiar después.
3. Confirma tu identidad de nuevo cuando se te pida. Crear, modificar y eliminar requieren esta confirmación.
4. Tras crearla, copia la `clientKey` completa y configúrala en tu programa. También puedes volver a verla después con el icono del ojo en la lista.
> **Nota:** Crear, modificar y eliminar surten efecto en pocos segundos. Si llamas justo después de crear una clave, puede devolver `ERROR_KEY_DOES_NOT_EXIST`; espera unos segundos y vuelve a intentarlo. Durante unos segundos después de eliminar una clave o de endurecer su configuración, las solicitudes que ya están en curso pueden procesarse con la configuración anterior.
## Límite de gasto
El límite fija cuántos puntos puede gastar una `clientKey` en un periodo (1,000 puntos = ¥1), entre 1 y 10,000,000,000 puntos. Hay cuatro periodos, con reinicio en hora de Beijing (UTC+8):
| Periodo | Cuándo se reinicia |
| --- | --- |
| Diario | Todos los días a las 00:00 |
| Semanal | Todos los lunes a las 00:00 |
| Mensual | El día 1 de cada mes a las 00:00 |
| Total único | No se reinicia. Cuando se agota, esta `clientKey` ya no puede crear tareas; sube el límite para seguir usándola |
- Se cuentan los puntos realmente cobrados: los puntos reembolsados por tareas fallidas o con tiempo agotado también vuelven al límite.
- Si el límite que queda en el periodo actual no alcanza para el cobro de puntos de la tarea, `createTask` devuelve [`ERROR_KEY_QUOTA_EXCEEDED`](https://docs.yescaptcha.com/es/api/errors.md#ERROR_KEY_QUOTA_EXCEEDED). No se cobran puntos y no cuenta para la [pausa automática](https://docs.yescaptcha.com/es/api/rate-limits.md).
- La lista del panel muestra cuánto ha usado cada `clientKey` en el periodo actual y cuándo se reinicia.
- El límite no es un saldo aparte: todas las `clientKey` descuentan del mismo saldo de la cuenta, y cuando el saldo de la cuenta no alcanza se devuelve `ERROR_ZERO_BALANCE` como siempre.
Si llamas a [`getBalance`](https://docs.yescaptcha.com/es/api/get-balance.md) con una `clientKey` que tiene límite, `balance` es el menor entre el saldo de la cuenta y el límite restante del periodo actual, y se añade el campo `keyQuotaRemaining` (límite restante, en puntos). Una `clientKey` sin límite no incluye este campo y la respuesta es igual que antes.
```json
{
"errorId": 0,
"balance": 20000,
"softBalance": 0,
"inviteBalance": 0,
"inviteBy": 0,
"keyQuotaRemaining": 20000
}
```
## Lista blanca de IP
Una `clientKey` con lista blanca de IP solo funciona para solicitudes enviadas desde las IP de la lista. Déjala vacía para no restringir.
- Escribe la **IP pública de la máquina que llama a la API de YesCaptcha** (su IP de salida), no el proxy de los parámetros de la tarea. Si llamas desde varias máquinas, añade la IP pública de cada una.
- Una dirección IPv4 o IPv6, o un rango CIDR, por línea, hasta 50 entradas. Una dirección sola permite únicamente esa IP.
- Escribe los rangos como dirección de red: `203.0.113.0/24` es válido, `203.0.113.5/24` no (los bits de host no son 0).
```text
203.0.113.10
198.51.100.0/24
2001:db8::/32
```
- Si la IP de la solicitud no está en la lista, `createTask` y `getBalance` devuelven [`ERROR_KEY_IP_NOT_ALLOWED`](https://docs.yescaptcha.com/es/api/errors.md#ERROR_KEY_IP_NOT_ALLOWED). No se cobran puntos y no cuenta para la pausa automática.
- Si tu IP de salida cambia (banda ancha doméstica, funciones en la nube, salidas rotativas), no configures la lista, o permite el rango completo.
## Vencimiento
- Cualquier `clientKey`, incluida la Key principal, puede tener una fecha de vencimiento dentro de los próximos diez años; después puedes modificarla o quitarla en cualquier momento.
- Una vez vencida, `createTask` y `getBalance` con esa clave devuelven [`ERROR_KEY_EXPIRED`](https://docs.yescaptcha.com/es/api/errors.md#ERROR_KEY_EXPIRED) y no se cobran puntos. Las tareas ya creadas se pueden seguir consultando con `getTaskResult`.
- Si una `clientKey` lleva mucho tiempo sin usarse, el sistema le asigna una fecha de vencimiento para proteger tu cuenta y te envía un correo antes de que venza. Ese vencimiento no se puede modificar: genera de nuevo la Key principal (el saldo pasa a la nueva automáticamente) o crea otra `clientKey`, y actualiza tu programa.
## Saldo, límite de tareas simultáneas y pausa automática
- **Saldo**: todas las `clientKey` descuentan del mismo saldo de la cuenta. Las recargas, los bonos VIP, las recompensas por referidos y la participación del desarrollador pertenecen a la cuenta, sin importar qué `clientKey` uses.
- **Límite de tareas simultáneas**: se cuenta por cuenta; todas tus `clientKey` comparten el mismo tope. Consulta [Límite de tareas simultáneas y pausa automática](https://docs.yescaptcha.com/es/api/rate-limits.md).
- **Pausa automática**: se cuenta por `clientKey`. Si una `clientKey` se pausa por demasiados errores, las demás no se ven afectadas.
## Códigos de error relacionados
| Código de error | Cuándo se devuelve |
| --- | --- |
| [`ERROR_KEY_QUOTA_EXCEEDED`](https://docs.yescaptcha.com/es/api/errors.md#ERROR_KEY_QUOTA_EXCEEDED) | El límite que queda en el periodo actual no alcanza para esta tarea (`createTask`) |
| [`ERROR_KEY_IP_NOT_ALLOWED`](https://docs.yescaptcha.com/es/api/errors.md#ERROR_KEY_IP_NOT_ALLOWED) | La IP de la solicitud no está en la lista blanca de IP de esta `clientKey` (`createTask`, `getBalance`) |
| [`ERROR_KEY_EXPIRED`](https://docs.yescaptcha.com/es/api/errors.md#ERROR_KEY_EXPIRED) | La `clientKey` ha vencido (`createTask`, `getBalance`) |
Ninguno de estos cobra puntos. Consulta [Códigos de error](https://docs.yescaptcha.com/es/api/errors.md) para saber qué hacer.
---
# Recarga y VIP
> Cómo recargar en YesCaptcha (WeChat Pay, Alipay, PayPal, criptomonedas); 1,000 puntos = ¥1. La recarga acumulada te sube automáticamente de VIP 1 a VIP 10, y cada recarga posterior recibe puntos de bono.
Source: https://docs.yescaptcha.com/es/account/recharge/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/account/recharge/
Recarga en la página de pago del Panel de [yescaptcha.com](https://yescaptcha.com/) ([yescaptcha.com/payment.html](https://yescaptcha.com/payment.html)). 1,000 puntos = ¥1, disponibles de inmediato. Cuando tu recarga acumulada alcanza ciertos montos, subes automáticamente a un Nivel VIP, y cada recarga posterior recibe puntos adicionales según el porcentaje de bono de ese nivel.
## Métodos de pago
| Método | Descripción |
| --- | --- |
| WeChat Pay | Pago con escaneo de código QR |
| Alipay | Pago con escaneo de código QR o redirección |
| PayPal | Para usuarios fuera de China |
| Criptomonedas | A través de Cryptomus; BTC, ETH, USDT y más |
| Transferencia bancaria | Contacta a Soporte; se acredita manualmente cuando finanzas lo confirma |
Tu historial de pagos está en la página de pago. Si tienes algún problema con un pago, [contacta a Soporte](https://docs.yescaptcha.com/es/help/contact.md) e indica los datos del pedido.
## Niveles VIP
Cuando tu recarga acumulada alcanza el umbral de la tabla, subes automáticamente a ese nivel; a partir de entonces, cada recarga recibe como puntos adicionales el porcentaje de bono correspondiente.
| Nivel | Recarga acumulada | Bono en cada recarga |
| --- | --- | --- |
| VIP 1 | ¥10 | 2% |
| VIP 2 | ¥100 | 5% |
| VIP 3 | ¥500 | 8% |
| VIP 4 | ¥1000 | 10% |
| VIP 5 | ¥2000 | 15% |
| VIP 6 | ¥3000 | 20% |
| VIP 7 | ¥6000 | 25% |
| VIP 8 | ¥12.000 | 30% |
| VIP 9 | ¥24.000 | 35% |
| VIP 10 | ¥48.000 | 40% |
- **Acumulativo**: no importa en cuántas recargas lo hagas, cuenta el total.
- **Se calcula con el acumulado después de la recarga**: por ejemplo, si tu primera recarga es de ¥1,000 y el total alcanza el umbral de VIP 4, esa misma recarga ya recibe el bono de VIP 4.
- Si te registras con el enlace de referido de un amigo, obtienes un Nivel VIP de inmediato; consulta [Recompensas por referidos](https://docs.yescaptcha.com/es/account/referral.md).
- Tu nivel actual y tu porcentaje de bono se muestran en la página de pago.
---
# Recompensas por referidos
> Recompensas por referidos de YesCaptcha. Los usuarios invitados obtienen un nivel VIP al crear su cuenta (tu nivel menos 1, de VIP 1 a VIP 6) y tú recibes el 20% de lo que gastan (10% cada uno cuando también aplica una participación del desarrollador). Puedes pasarlo a tu saldo o retirarlo desde ¥100 en el Panel.
Source: https://docs.yescaptcha.com/es/account/referral/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/account/referral/
Invita a tus amigos a YesCaptcha: al crear su cuenta obtienen un nivel VIP y tú recibes el 20% de lo que gastan. Las recompensas se pueden pasar a tu saldo o retirar desde el Panel cuando lleguen a ¥100.
## Cómo invitar
Inicia sesión en el Panel de [yescaptcha.com](https://yescaptcha.com/). En el panel de Recompensas del Resumen verás tu enlace de referido, cuántas personas has invitado y tus recompensas acumuladas. Envía el enlace a tus amigos; ellos crean su cuenta a través de él.
## Reglas
1. **El VIP de tu amigo**: al crear su cuenta, tu amigo obtiene directamente un nivel VIP igual al tuyo menos 1, con un mínimo de VIP 1 y un máximo de VIP 6. Por ejemplo, si eres VIP 6, tu amigo empieza en VIP 5. Los porcentajes de bono de cada nivel están en [Recarga y VIP](https://docs.yescaptcha.com/es/account/recharge.md).
2. **Tu recompensa**: cada vez que tu amigo gasta (cobro de puntos por reconocimiento), recibes el **20%** del importe.
3. **Cuando también hay participación del desarrollador**: si las tareas de tu amigo llevan además el ID de un desarrollador (consulta [Participación del desarrollador](https://docs.yescaptcha.com/es/account/developer.md)), quien invita y el desarrollador reciben **10% cada uno**.
4. Si tu amigo reporta un error de reconocimiento y recibe un reembolso tras reportar por esa tarea, la recompensa correspondiente se descuenta.
5. Puedes consultar el saldo de recompensas con `inviteBalance` de [getBalance](https://docs.yescaptcha.com/es/api/get-balance.md) (unidad: yuanes).
## Usar las recompensas
- **Pasar a saldo**: en el Panel, transfiere las recompensas a tu saldo y úsalas para el reconocimiento a razón de 1,000 puntos = ¥1.
- **Retirar**: cuando las recompensas lleguen a **¥100**, envía una solicitud de retiro en el Panel; el pago se realiza tras la revisión.
- Eres responsable de declarar el impuesto sobre la renta de los retiros.
## Escribe sobre nosotros
Si publicas recomendaciones, tutoriales, experiencias, extensiones o bibliotecas de código sobre YesCaptcha en foros, blogs, Zhihu, cuentas de WeChat u otras plataformas, envía el enlace a Soporte. Lo evaluaremos y, según la calidad del contenido, podremos darte puntos o un nivel VIP como recompensa.
Si las reglas de recompensas cambian, prevalecen esta página y el [registro de actualizaciones del servicio](https://docs.yescaptcha.com/es/changelog.md).
---
# Participación del desarrollador
> Participación del desarrollador de YesCaptcha. Incluye tu softID en las solicitudes que envía tu software para sus usuarios y recibe el 20% de lo que gastan (10% cada uno cuando además hay un referidor); pásala a tu saldo o retírala desde ¥100 en el Panel.
Source: https://docs.yescaptcha.com/es/account/developer/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/account/developer/
Si tu software, script o extensión usa YesCaptcha, incluye tu ID de desarrollador (`softID`) en las solicitudes que envía para otros usuarios y recibirás una participación de lo que gasten. Los usuarios siguen usando su propio `clientKey` y sus propios puntos; la participación no les cuesta nada extra.
## Integración
1. Llama a [getSoftID](https://docs.yescaptcha.com/es/api/get-soft-id.md) con tu propio `clientKey` para obtener tu ID de desarrollador:
```json
{
"errorId": 0,
"softID": 3,
"balance": 0.004
}
```
2. En cada solicitud `createTask` que envíe tu software, añade el campo `softID` de nivel superior (al mismo nivel que `clientKey` y `task`; distingue mayúsculas y minúsculas):
```json
{
"clientKey": "THE_USERS_CLIENT_KEY",
"task": {
"type": "NoCaptchaTaskProxyless",
"websiteURL": "https://www.google.com/recaptcha/api2/demo",
"websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"
},
"softID": 3
}
```
`clientKey` es la clave del propio usuario.
## Reglas de la participación
- Las tareas que llevan tu `softID` acreditan el **20%** del gasto real del usuario a tu participación del desarrollador.
- Si además el usuario llegó por invitación de otra persona (consulta [Recompensa por referidos](https://docs.yescaptcha.com/es/account/referral.md)), el desarrollador y quien invitó **reciben el 10% cada uno**.
- Solo las tareas con cobro de puntos generan participación; las tareas fallidas o con tiempo agotado que se reembolsan no. Si el usuario reporta un resultado incorrecto y recibe un reembolso tras reportar, la participación de esa tarea se descuenta.
- Consulta el saldo de tu participación (en CNY) con `balance` de [getSoftID](https://docs.yescaptcha.com/es/api/get-soft-id.md) o con `softBalance` de [getBalance](https://docs.yescaptcha.com/es/api/get-balance.md).
## Uso de la participación
- **Pasar a saldo**: transfiérela al saldo de tu cuenta en el Panel, a razón de 1,000 puntos = ¥1.
- **Retirar**: cuando alcance **¥100**, envía una solicitud de retiro en el Panel; se paga después de la revisión.
- Eres responsable de declarar el impuesto sobre la renta de los retiros.
---
# Preguntas frecuentes
> Preguntas frecuentes de YesCaptcha. Si se cobran las tareas fallidas, cuánto dura un token, tasa de aprobación, reconocimiento humano o por máquina, bloqueo de cuentas, usar un ClientKey en varios lugares, qué endpoint elegir, extensión frente a API.
Source: https://docs.yescaptcha.com/es/help/faq/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/help/faq/
## ¿Se cobran puntos cuando YesCaptcha no logra resolver un captcha?
No. Las tareas fallidas (`ERROR_CAPTCHA_UNSOLVABLE`) y las que superan el tiempo de espera (`ERROR_TASK_TIMEOUT`) se reembolsan automáticamente, y las solicitudes que devuelven un código de error no se cobran. Un token que el sitio de destino rechaza cuenta como éxito, porque no podemos saber la decisión del sitio; los resultados incorrectos de reconocimiento de imágenes se pueden reportar para solicitar el reembolso. Consulta [Facturación y reembolsos](https://docs.yescaptcha.com/es/getting-started/billing.md).
## ¿Cuánto cuesta cada reconocimiento?
Cada tipo de tarea tiene un precio fijo en puntos (1,000 puntos = ¥1), y los precios varían según el tipo. Todos los precios están en [Tipos de tarea y precios](https://docs.yescaptcha.com/es/tasks.md); hay una versión legible por máquina en [/data/task-types.json](https://docs.yescaptcha.com/data/task-types.json).
## ¿Cuánto tiempo es válido un token?
Los tokens de reCAPTCHA, hCaptcha y Turnstile son de un solo uso. Los tokens de reCAPTCHA son válidos durante unos 120 segundos; conviene enviarlos en los primeros 60 segundos. El proveedor del captcha define el plazo de validez.
## ¿Por qué algunos tokens no son aceptados?
Lo decide el sitio de destino. Evalúa la puntuación, la IP, el entorno del navegador y otros factores, y puede cambiar su umbral en cualquier momento, por lo que la tasa de aprobación varía según el sitio. Prueba otros tipos de tarea para el mismo captcha, usa un tipo con tu propio proxy y envía el token a través del mismo proxy, o cambia a reconocimiento de imágenes y haz clic en un navegador real.
## ¿Cuánto tarda el reconocimiento?
Las tareas asíncronas suelen tardar de unos pocos segundos a unas decenas de segundos, y como máximo unos 110 segundos (de 180 a 220 en algunos tipos); al superar el tiempo de espera se reembolsan automáticamente. El reconocimiento de imágenes y el de imagen a texto son síncronos y responden en una sola solicitud.
## ¿El reconocimiento lo hacen personas o máquinas?
Máquinas, mediante modelos de aprendizaje automático.
## ¿Usar YesCaptcha puede provocar que bloqueen mi cuenta?
Solo devolvemos el resultado del reconocimiento y nunca accedemos a tu cuenta en el sitio de destino. Cómo evalúa el sitio la actividad y si bloquea cuentas depende del propio sitio; respeta sus reglas. YesCaptcha solo puede usarse con fines legales y está prohibido su uso con fines ilegales.
## ¿Puedo usar un mismo ClientKey en varios programas o navegadores a la vez?
Sí. Las solicitudes de una misma cuenta comparten el [límite de tareas simultáneas](https://docs.yescaptcha.com/es/api/rate-limits.md) y el mismo saldo.
## ¿Debo usar el endpoint global o el endpoint China?
Si tu servidor está en China continental, usa `cn.yescaptcha.com`; en el resto de regiones, usa `api.yescaptcha.com`. Consulta el resultado en el mismo endpoint donde creaste la tarea. Consulta [Endpoints](https://docs.yescaptcha.com/es/getting-started/endpoints.md).
## ¿Qué diferencia hay entre la extensión y la API?
La extensión usa la misma API para reconocer captchas. Se instala gratis, cobra puntos según las llamadas a la API que realiza y es adecuada para usar en el navegador sin escribir código; la API es adecuada para procesar lotes desde un programa. Consulta [Extensión del navegador](https://docs.yescaptcha.com/es/extension.md).
## ¿Por qué estoy en pausa y recibo ERROR\_IP\_BLOCKED\_5MIN?
Tu ClientKey generó demasiadas solicitudes con error en un minuto y se pausó automáticamente durante unos minutos; se reanuda solo al terminar el plazo. El campo `blockReason` de la respuesta es el código de error que activó la pausa; corrige tu programa según ese código. Consulta [Límite de tareas simultáneas y pausa automática](https://docs.yescaptcha.com/es/api/rate-limits.md).
## ¿Qué sitios son compatibles?
Ofrecemos reconocimiento por tipo de captcha, no para sitios concretos. Que se apruebe o no depende de la configuración del sitio de destino, así que conviene probar primero con un lote pequeño. Cuando un sitio aún no es compatible, se devuelve `ERROR_DOMAIN_NOT_ALLOWED`.
---
# Problemas de conexión y red
> Qué hacer si no puedes conectarte a la API de YesCaptcha: pasos para diagnosticar Failed to establish a new connection, fallos de DNS, interferencia de software de proxy y errores SSL (Certificate has expired, SSLEOFError).
Source: https://docs.yescaptcha.com/es/help/troubleshooting/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/help/troubleshooting/
Los errores de conexión al llamar a la API (por ejemplo `Failed to establish a new connection`, `getaddrinfo failed`, timeouts o errores SSL) suelen deberse a la red de tu equipo, al DNS o al software de proxy. Sigue estos pasos en orden.
## 1\. Prueba primero con el otro endpoint
YesCaptcha tiene dos endpoints: `https://api.yescaptcha.com` (global) y `https://cn.yescaptcha.com` (China). En servidores de China continental usa el endpoint China; en el resto del mundo, el global. Si cambias de endpoint, consulta también los resultados en el mismo endpoint.
```bash
curl -s https://api.yescaptcha.com/getBalance -H 'Content-Type: application/json' -d '{"clientKey": "YOUR_CLIENT_KEY"}'
curl -s https://cn.yescaptcha.com/getBalance -H 'Content-Type: application/json' -d '{"clientKey": "YOUR_CLIENT_KEY"}'
```
Si cualquiera de los dos devuelve JSON, tu red funciona y el problema está en la ruta hacia el otro endpoint.
## 2\. Revisa el software de proxy
Para acceder a YesCaptcha no necesitas proxy. Si tienes software de proxy o VPN activo:
- Desactívalo y vuelve a probar;
- Si debe permanecer activo, usa el modo por reglas (PAC) en lugar del modo global, o añade `api.yescaptcha.com` y `cn.yescaptcha.com` a la lista de conexión directa;
- Si en Python, con un proxy activo, aparece `SSLEOFError(8, 'EOF occurred in violation of protocol')`, lo más probable es que también lo cause el proxy; desactívalo o haz que estos dos dominios se conecten directamente.
## 3\. Revisa la red y el DNS
```bash
ping api.yescaptcha.com
```
- Si indica que no encuentra el host: falló la resolución de DNS. Vacía la caché de DNS (Windows: `ipconfig /flushdns`; macOS: `sudo dscacheutil -flushcache; sudo killall -HUP mDNSResponder`), o cambia el DNS de tu equipo a uno público (por ejemplo `223.5.5.5`, `119.29.29.29` o `8.8.8.8`) y vuelve a probar.
- Si el ping falla pero la dirección se resuelve: puede que la red bloquee ICMP, lo que no significa que la API sea inaccesible. Guíate por el resultado del curl del paso 1.
## 4\. Errores de certificado SSL
- Si aparece `Certificate has expired` o `certificate verify failed`: primero comprueba que la **hora del sistema** de tu equipo sea correcta; después actualiza el sistema operativo, el `certifi` de Python, Postman u otras herramientas a la última versión para que incluyan los certificados raíz más recientes.
- Usa siempre `https://`. No cambies a `http://` ni desactives la verificación de certificados para evitar el error.
## 5\. Si sigue sin funcionar
[Contacta con soporte](https://docs.yescaptcha.com/es/help/contact.md) e incluye: el mensaje de error completo, el endpoint que usas, la región donde está tu servidor y la salida del curl del paso 1.
---
# Contáctanos
> Contacta con el soporte de YesCaptcha por WeChat, QQ, WhatsApp, LINE, Telegram @yescaptcha_official o correo yescaptcha@gmail.com, de 9:00 a 21:00 UTC+8.
Source: https://docs.yescaptcha.com/es/help/contact/ · Last verified: 2026-10-15
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/help/contact/
El horario de soporte de YesCaptcha es de **9:00 a 21:00 UTC+8** (hora de Beijing). Si tardamos en responder, déjanos un mensaje y lo atenderemos lo antes posible.
- Correo: [yescaptcha@gmail.com](mailto:yescaptcha@gmail.com)
- Telegram: [@yescaptcha\_official](https://t.me/yescaptcha_official)
Escanea el código para añadirnos:
**WeChat**Escanea con WeChat para añadirnos; podemos agregarte al grupo de usuarios
**QQ**Escanea con QQ para añadirnos
**WhatsApp**Escanea con la cámara de WhatsApp
**LINE**Escanea desde "Añadir amigos" en LINE
**[Telegram](https://t.me/yescaptcha_official)**@yescaptcha\_official
Al contactarnos, incluye:
- El correo de tu cuenta o tu ID de usuario (**nunca** envíes tu `clientKey`);
- El `taskId`, el código de error y la hora en que ocurrió;
- Qué tipo de tarea y qué endpoint usaste (`api.yescaptcha.com` o `cn.yescaptcha.com`).
Muchas preguntas se resuelven en las [preguntas frecuentes](https://docs.yescaptcha.com/es/help/faq.md), los [códigos de error](https://docs.yescaptcha.com/es/api/errors.md) y [Problemas de conexión y red](https://docs.yescaptcha.com/es/help/troubleshooting.md).
---
# Registro de cambios del servicio
> Cambios de YesCaptcha que afectan a los usuarios, por fecha. Tipos de tarea nuevos y retirados, reglas de cobro y reembolso, límite de tareas simultáneas y migración de la documentación. Se registra desde octubre de 2026.
Source: https://docs.yescaptcha.com/es/changelog/ · Last verified: 2026-10-19
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/changelog/
Aquí se registran por fecha los cambios que afectan a los usuarios: tipos de tarea nuevos o retirados, reglas de cobro, reglas de límite, etc. Lo más reciente va primero.
## 2026-10-19
- **La página de verificación de Cloudflare ya no se marca como “No recomendada”**: se reconstruyó el servicio de `CloudFlareTaskS2` y `CloudFlareTaskS3`; una tarea suele tardar de 6 a 35 segundos. Ambos tipos tienen los mismos parámetros, resultados y efectividad; los precios no cambian (25 y 20 puntos). El proxy solo admite `http://` (con usuario y contraseña opcionales) y `socks5://` sin usuario ni contraseña; los proxies `https://` y las direcciones locales o de red interna se rechazan al crear la tarea (sin cobro de puntos). `userAgent` solo se usa si es de Chrome de escritorio en Linux; en las solicitudes posteriores usa el `user_agent` del resultado. Si envías `requiredCookies`, la tarea solo se considera exitosa si se obtienen todas. Consulta [Página de verificación de Cloudflare](https://docs.yescaptcha.com/es/tasks/cloudflare-challenge.md).
## 2026-10-16
- **Los tipos de FunCaptcha que devuelven token no se recomiendan por ahora**: tienen un costo alto y no hay una solución estable. `FunCaptchaTask` pasa a costar 30 puntos por tarea (antes 15). `FunCaptchaTaskProxyless` sigue sin resolverse con éxito; las tareas fallidas tienen reembolso de puntos automático. Si necesitas pasar FunCaptcha, usa [reconocimiento de imágenes de FunCaptcha](https://docs.yescaptcha.com/es/tasks/funcaptcha-classification.md) o la extensión del navegador.
## 2026-10-15
- **Migración de la documentación**: la documentación pasó de Confluence a este sitio (docs.yescaptcha.com), en chino e inglés (y otros idiomas), con el chino como referencia. Hay [llms.txt](https://docs.yescaptcha.com/llms.txt), [OpenAPI](https://docs.yescaptcha.com/openapi.json) y una versión en Markdown de cada página, para que las lean IA y programas.
- **El reembolso tras reportar se liquida unas 24 horas después**: en los tipos de reconocimiento de imágenes, al reportar un error de reconocimiento ya no se reembolsa de inmediato, sino que se liquida de forma conjunta unas 24 horas después; si tu tasa de fallos es claramente superior a la del mismo periodo, se reembolsa según la tasa de fallos de ese periodo. Consulta [Cobro y reembolso de puntos](https://docs.yescaptcha.com/es/getting-started/billing.md).
- **Límite de tareas simultáneas**: ahora se cuentan por cuenta y por tipo de tarea las tareas en proceso; al superar el límite se devuelve `ERROR_THREADS_MAXIMUM`, sin cobro de puntos y sin contar para la pausa automática. Cuando se definan los límites de cada tipo, se publicarán en [Límite de tareas simultáneas y pausa automática](https://docs.yescaptcha.com/es/api/rate-limits.md).
- **Más tipos de tarea públicos**: se documentan `HCaptchaTask`, `NoCaptchaTask`, `TurnstileTask` y `RecaptchaV2EnterpriseTask` (con proxy propio), además de `FunCaptchaTaskProxylessM1`, `FunCaptchaTask` y `HCaptchaTaskProxylessM1`.
- **Tipos de FunCaptcha que devuelven token**: `FunCaptchaTaskProxylessM1` y `FunCaptchaTask` están disponibles; la ruta de `FunCaptchaTaskProxyless` no logra resolver con éxito desde alrededor del 2026-09-10; las tareas fallidas tienen reembolso de puntos automático.
- **Retirados**: la serie de huella personalizada K1 de reCAPTCHA, `FunCaptchaTaskS1`, `CloudFlareTaskS1`, `TurnstileTaskS2`, `TurnstileTaskProxylessS2`, `bCaptcha2Classification` y `GeneralClassification` dejan de prestar servicio.
## Antes del 2026-10-15
- El servicio de alquiler autogestionado de **servidores dedicados** se ha retirado.