CAPSOLVER
Blog
n8n
Cómo resolver acertijos visuales en n8n con el Motor de Visión de CapSolver

Cómo resolver puzzles visuales en n8n con CapSolver

Logo of CapSolver

Aloísio Vítor

Image Processing Expert

18-Mar-2026

Los acertijos visuales están en todas partes: CAPTCHAs de deslizador que requieren arrastrar una pieza a la posición correcta, desafíos de rotación donde alineas una imagen, cuadrículas de selección de objetos y reconocimiento de texto en GIF animados. Estos no son CAPTCHAs tradicionales basados en texto ni desafíos basados en tokens (como reCAPTCHA o Turnstile) que devuelven una cadena que envías con un formulario. Son desafíos visuales basados en imágenes donde la entrada es una imagen y la salida es una medición: una distancia en píxeles, un ángulo en grados, un conjunto de coordenadas o texto reconocido.

Eso es lo que CapSolver's Vision Engine resuelve. Utiliza inteligencia artificial para analizar la imagen del acertijo visual y devolver la respuesta precisa que necesita tu automatización para continuar.

En esta guía, aprenderás a usar el Vision Engine en n8n a través del nodo de la comunidad de CapSolver. El recorrido cubre el flujo de trabajo básico de la API del Solver y un solucionador de rompecabezas de deslizador práctico que obtiene imágenes de rompecabezas, las convierte en base64, resuelve el deslizador y devuelve la distancia en píxeles.

Importante: Vision Engine es una operación de reconocimiento, no una operación de token. Eso significa que el resultado vuelve instantáneamente en una sola llamada a la API: no hay sondeo, no hay bucle getTaskResult y no hay espera por timeout. Envías la imagen y obtienes la respuesta.

Cómo difiere Vision Engine de otras operaciones de CapSolver

La mayoría de las operaciones de CapSolver en n8n son tareas de token. Envías parámetros del sitio (URL, clave del sitio, proxy), CapSolver resuelve el desafío en segundo plano y tu flujo de trabajo sondea el resultado. La salida es una cadena de token que luego envías al sitio objetivo.

Vision Engine funciona de manera diferente:

Aspecto Operaciones de Token (reCAPTCHA, Turnstile, etc.) Vision Engine (Reconocimiento)
Recurso Token Reconocimiento
Entrada URL del sitio, clave del sitio, proxy Imagen(es) en base64, nombre del módulo
Procesamiento Asíncrono — sondea el resultado Instantáneo — llamada única a la API
Salida Cadena de token Píxeles, grados, coordenadas o texto
Proxy A menudo necesario No es necesario
Caso de uso Enviar token para evitar la barrera de desafío Interpretar el acertijo visual para automatizar la interacción

Vision Engine es más cercano al reconocimiento de imagen a texto (OCR) que a la resolución de reCAPTCHA, pero va más allá del reconocimiento simple de texto. Mientras que el OCR lee caracteres de una imagen estática, Vision Engine entiende las relaciones espaciales: puede calcular cuántos píxeles se deben arrastrar una pieza de deslizador, qué ángulo se debe rotar una imagen, qué áreas de una imagen coinciden con una pregunta o qué texto está oculto en un GIF animado.

Módulos disponibles

Vision Engine soporta múltiples modelos de IA, cada uno diseñado para un tipo específico de acertijo visual:

Módulo Propósito Entrada Devuelve
slider_1 Resolución de rompecabezas de deslizador image (pieza del rompecabezas) + imageBackground (fondo con ranura) Distancia en píxeles
rotate_1 Rotación de imagen única image + imageBackground Ángulo en grados
rotate_2 Rotación de múltiples imágenes (interna + externa) image (imagen interna) Ángulo en grados
shein Selección de objeto/área image + question (qué seleccionar) Matriz de rectángulos [{x1, y1, x2, y2}]
ocr_gif Reconocimiento de texto en GIF animado image (base64 del GIF) Cadena de texto reconocido

Cuándo usar cada módulo

slider_1 — El tipo más común de CAPTCHA visual. El usuario ve una imagen de fondo con una pieza faltante y una pieza de rompecabezas separada. El objetivo es determinar cuántos píxeles a la derecha debe arrastrarse la pieza. Se requieren tanto image (la pieza del rompecabezas) como imageBackground (el fondo completo con la ranura).

rotate_1 — Una imagen única que debe rotarse a la orientación correcta. Se requieren tanto image como imageBackground. El motor devuelve el ángulo en grados.

rotate_2 — Dos imágenes concéntricas (una imagen interna y un anillo externo). La imagen interna debe rotarse para alinearse con la externa. Solo se necesita image. El motor devuelve el ángulo.

shein — Usado para desafíos que piden "seleccionar los elementos que coinciden" o "tocar el área correcta". Requiere image más un parámetro question que describa qué encontrar. Devuelve coordenadas de cajas delimitadoras para cada área que coincide.

ocr_gif — GIFs animados donde el texto aparece en frames, haciendo imposible su lectura para OCR estándar. El motor analiza la animación y extrae el texto.

Requisitos previos

Antes de comenzar, asegúrate de tener:

  1. Una instancia de n8n (autohospedada o en la nube)
  2. Una cuenta de CapSolver con clave de API y saldo — regístrate aquí
  3. El nodo de la comunidad de CapSolver instalado en n8n (n8n-nodes-capsolver)
  4. Una credencial de CapSolver configurada en n8n (Configuración > Credenciales > CapSolver API)

No se requiere proxy para tareas de Vision Engine.

Configuración del nodo de CapSolver para Vision Engine

En el nodo de CapSolver de n8n, configura estos ajustes:

Configuración Valor
Recurso Reconocimiento
Operación Vision Engine
módulo Nombre del modelo (ejemplo: slider_1, rotate_1, ocr_gif)
imagen Cadena codificada en base64 (sin prefijo data:image/...;base64,)
imageBackground Imagen de fondo codificada en base64 (opcional — requerida para slider_1 y rotate_1)
pregunta Pregunta de texto (opcional — requerida solo para el módulo shein)
websiteURL URL de la página de origen (opcional — puede mejorar la precisión)

El campo type se establece automáticamente en VisionEngine cuando seleccionas la operación Vision Engine.

Requisitos para imágenes en base64

Los campos image y imageBackground deben ser cadenas base64 sin formato — sin prefijo URI de datos, sin saltos de línea:

  • Correcto: /9j/4AAQSkZJRgABA... (base64 sin formato)
  • Incorrecto: data:image/jpeg;base64,/9j/4AAQSkZJRgABA... (tiene prefijo)

Si tu imagen de origen es una URL, debes obtenerla primero y convertirla a base64. Si ya tiene el prefijo data:image/...;base64,, elimínalo antes de pasarlo al nodo de CapSolver.

Flujo de trabajo 1: Vision Engine — API de Solucionador

Este flujo expone Vision Engine como un endpoint de API REST simple. Envía una solicitud POST con el nombre del módulo y la imagen en base64, y obtén la solución como JSON.

Flujo de nodos

Copy 
Recibir solicitud del solucionador (Webhook POST)
  → Validar entrada (Código)
    → Resolver acertijo visual (CapSolver — Reconocimiento — Vision Engine)
      → ¿Error de Vision Engine? (IF)
        → true: Responder al Webhook con error
        → false: Responder al Webhook (Éxito)

Cómo funciona

1. Recibir solicitud del solucionador

Un endpoint de webhook acepta solicitudes POST con un cuerpo JSON que contiene:

json Copy 
{
  "module": "slider_1",
  "image": "/9j/4AAQSkZJRgABA...",
  "imageBackground": "/9j/4AAQSkZJRgABA...",
  "question": "",
  "websiteURL": ""
}

2. Validar entrada

El nodo de código verifica que image exista y que module sea uno de los valores admitidos (slider_1, rotate_1, rotate_2, shein, ocr_gif). Si la validación falla, establece un campo error.

3. Resolver acertijo visual

El nodo de CapSolver se configura con:

  • Recurso: Reconocimiento
  • Operación: Vision Engine
  • módulo: del cuerpo de la solicitud
  • imagen: del cuerpo de la solicitud
  • imageBackground: del cuerpo de la solicitud (cadena vacía si no se proporciona)
  • pregunta: del cuerpo de la solicitud (cadena vacía si no se proporciona)

Como es una tarea de Reconocimiento, el resultado vuelve instantáneamente.

4. Manejo de errores

El nodo IF verifica errores. Si el nodo de CapSolver devolvió un error (módulo incorrecto, imagen inválida, etc.), se activa el webhook de error. De lo contrario, se devuelve la respuesta de éxito con la solución.

Solicitud y respuesta esperadas

Solicitud de rompecabezas de deslizador:

bash Copy 
curl -X POST https://your-n8n-instance.com/webhook/vision-engine-solver \
  -H "Content-Type: application/json" \
  -d '{
    "module": "slider_1",
    "image": "BASE64_PUZZLE_PIECE",
    "imageBackground": "BASE64_BACKGROUND"
  }'

Respuesta exitosa:

json Copy 
{
  "solution": {
    "distance": 142,
    "module": "slider_1"
  }
}

Solicitud de OCR de GIF:

bash Copy 
curl -X POST https://your-n8n-instance.com/webhook/vision-engine-solver \
  -H "Content-Type: application/json" \
  -d '{
    "module": "ocr_gif",
    "image": "BASE64_GIF_DATA"
  }'

Respuesta exitosa:

json Copy 
{
  "solution": {
    "text": "x7Km9",
    "module": "ocr_gif"
  }
}

Importar este flujo

Haz clic para expandir el JSON del flujo
json Copy 
{
  "name": "Vision Engine — Solver API",
  "nodes": [
    {
      "parameters": {
        "content": "## Vision Engine — Solver API\n\n**¿Para quién es?** Desarrolladores y equipos de automatización que necesitan resolver acertijos visuales (deslizadores, rotaciones, selección de objetos, OCR de GIF) a través de un endpoint REST simple.\n\n**¿Qué hace?** Acepta una imagen codificada en base64 y un nombre de módulo, la envía al Vision Engine de CapSolver y devuelve la solución instantáneamente.\n\n**¿Cómo funciona?**\n1. El webhook recibe POST con `module`, `image` y `imageBackground`/`question` opcionales\n2. El nodo de código valida la entrada (la imagen existe, el módulo es válido)\n3. El nodo de CapSolver de Reconocimiento resuelve el acertijo visual\n4. Devuelve la solución o error como JSON\n\n**Configuración:**\n1. Agrega tu clave de API de CapSolver bajo **Configuración → Credenciales**\n2. Activa el flujo\n3. Envía POST a `/webhook/vision-engine-solver` con tus datos de imagen",
        "height": 560,
        "width": 460,
        "color": 1
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [-920, -380],
      "id": "sticky-ve-main-001",
      "name": "Nota adhesiva"
    },
    {
      "parameters": {
        "content": "### Validación de entrada\nVerifica que `image` esté presente y `module` sea uno de: slider_1, rotate_1, rotate_2, shein, ocr_gif",
        "height": 480,
        "width": 440,
        "color": 6
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [-100, -280],
      "id": "sticky-ve-section-002",
      "name": "Nota adhesiva1"
    },
    {
      "parameters": {
        "content": "### Vision Engine de CapSolver\nRecurso de Reconocimiento — resultado instantáneo, sin sondeo. Devuelve distancia, ángulo, coordenadas o texto según el módulo.",
        "height": 480,
        "width": 440,
        "color": 6
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [380, -280],
      "id": "sticky-ve-section-003",
      "name": "Nota adhesiva2"
    },
    {
      "parameters": {
        "content": "### Manejo de errores\nVerifica errores de CapSolver (imagen inválida, módulo no admitido, etc.) y devuelve una respuesta de error estructurada.",
        "height": 480,
        "width": 440,
        "color": 6
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [860, -280],
      "id": "sticky-ve-section-004",
      "name": "Nota adhesiva3"
    },
    {
      "parameters": {
        "content": "### Desencadenador de Webhook\nPOST /webhook/vision-engine-solver con cuerpo JSON que contiene módulo, imagen y opciones imageBackground / question.",
        "height": 480,
        "width": 440,
        "color": 6
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [-580, -280],
      "id": "sticky-ve-section-005",
      "name": "Nota adhesiva4"
    },
    {
      "parameters": {
        "content": "### Respuesta de éxito\nDevuelve el objeto de solución completo de CapSolver — el contenido varía según el tipo de módulo.",
        "height": 480,
        "width": 440,
        "color": 6
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [1340, -280],
      "id": "sticky-ve-section-006",
      "name": "Nota adhesiva5"
    },
    {
      "parameters": {
        "content": "### Respuesta de error\nDevuelve el mensaje de error de CapSolver o de la validación de entrada.",
        "height": 480,
        "width": 440,
        "color": 6
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [1340, 240],
      "id": "sticky-ve-section-007",
      "name": "Nota adhesiva6"
    },
    {
      "parameters": {
        "httpMethod": "POST",
        "path": "vision-engine-solver",
        "responseMode": "responseNode",
        "options": {}
      },
      "type": "n8n-nodes-base.webhook",
      "typeVersion": 2,
      "position": [-540, 0],
      "id": "ve-api-11111111-1111-1111-1111-111111111101",
      "name": "Recibir solicitud del solucionador",
      "webhookId": "ve-api-11111111-aaaa-bbbb-cccc-111111111101"
    },
    {
      "parameters": {
        "jsCode": "const body = $input.first().json.body || {};\nconst validModules = ['slider_1', 'rotate_1', 'rotate_2', 'shein', 'ocr_gif'];\n\nconst module = (body.module || '').trim();\nconst image = (body.image || '').trim();\nconst imageBackground = (body.imageBackground || '').trim();\nconst question = (body.question || '').trim();\nconst websiteURL = (body.websiteURL || '').trim();\n\n// Validar campos requeridos\nif (!image) {\n  return [{ json: { error: 'Campo requerido faltante: image (codificado en base64)' } }];\n}\n\nif (!module) {\n  return [{ json: { error: 'Campo requerido faltante: module' } }];\n}\n\nif (!validModules.includes(module)) {\n  return [{ json: { error: `Módulo inválido: ${module}. Debe ser uno de: ${validModules.join(', ')}` } }];\n}\n\n// Validación específica del módulo\nif ((module === 'slider_1' || module === 'rotate_2') && !imageBackground) {\n  return [{ json: { error: `El módulo ${module} requiere imageBackground` } }];\n}\n\nif (module === 'shein' && !question) {\n  return [{ json: { error: 'El módulo shein requiere un parámetro question' } }];\n}\n\nreturn [{ json: {\n  module,\n  image,\n  imageBackground,\n  question,\n  websiteURL,\n  validated: true\n} }];"
      },
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [-60, 0],
      "id": "ve-api-11111111-1111-1111-1111-111111111102",
      "name": "Validar entrada"
    },
    {
      "parameters": {
        "resource": "Reconocimiento",
        "operation": "Vision Engine",
        "module": "={{ $json.module }}",
        "image": "={{ $json.image }}",
        "imageBackground": "={{ $json.imageBackground || '' }}",
        "question": "={{ $json.question || '' }}",
        "websiteURL": "={{ $json.websiteURL || '' }}"
      },
      "type": "n8n-nodes-capsolver.capSolver",
      "typeVersion": 1,
      "position": [420, 0],
      "id": "ve-api-11111111-1111-1111-1111-111111111103",
      "name": "Resolver acertijo visual",
      "onError": "continueRegularOutput",
      "credentials": {
        "capSolverApi": {
          "id": "YOUR_CREDENTIAL_ID",
          "name": "Cuenta de CapSolver"
        }
      }
    },
    {
      "parameters": {
        "conditions": {
          "options": {
"caseSensitive": true,
            "leftValue": "",
            "typeValidation": "loose",
            "version": 2
          },
          "conditions": [
            {
              "id": "ve-err-001",
              "leftValue": "={{ $json.error }}",
              "operator": {
                "type": "string",
                "operation": "isNotEmpty",
                "singleValue": true
              }
            }
          ],
          "combinator": "and"
        },
        "options": {}
      },
      "type": "n8n-nodes-base.if",
      "typeVersion": 2.2,
      "position": [900, 0],
      "id": "ve-api-11111111-1111-1111-1111-111111111104",
      "name": "¿Error del Motor de Visión?"
    },
    {
      "parameters": {
        "respondWith": "json",
        "responseBody": "={{ JSON.stringify($json.data) }}",
        "options": {}
      },
      "type": "n8n-nodes-base.respondToWebhook",
      "typeVersion": 1.1,
      "position": [1380, -80],
      "id": "ve-api-11111111-1111-1111-1111-111111111105",
      "name": "Responder al Webhook"
    },
    {
      "parameters": {
        "respondWith": "json",
        "responseBody": "={{ JSON.stringify({ error: $json.error }) }}",
        "options": {
          "responseCode": 400
        }
      },
      "type": "n8n-nodes-base.respondToWebhook",
      "typeVersion": 1.1,
      "position": [1380, 120],
      "id": "ve-api-11111111-1111-1111-1111-111111111106",
      "name": "Responder al Webhook de Error"
    }
  ],
  "connections": {
    "Receive Solver Request": {
      "main": [
        [
          {
            "node": "Validate Input",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Validate Input": {
      "main": [
        [
          {
            "node": "Solve Visual Puzzle",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Solve Visual Puzzle": {
      "main": [
        [
          {
            "node": "¿Error del Motor de Visión?",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "¿Error del Motor de Visión?": {
      "main": [
        [
          {
            "node": "Responder al Webhook de Error",
            "type": "main",
            "index": 0
          }
        ],
        [
          {
            "node": "Responder al Webhook",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  },
  "active": false,
  "settings": {
    "executionOrder": "v1"
  }
}

Workflow 2: Solucionador de Rompecabezas de Deslizamiento — Recuperar y Resolver

Este flujo de trabajo demuestra un solucionador práctico de rompecabezas de deslizamiento de extremo a extremo. Recupera las imágenes de la pieza del rompecabezas y el fondo desde URLs, las convierte a base64, las envía al Motor de Visión con el módulo slider_1 y devuelve la distancia en píxeles necesaria para completar el deslizador.

Este es el patrón que utilizarías al integrar la resolución de CAPTCHA de deslizamiento en una automatización más grande: la distancia devuelta le dice a tu automatización de navegadores (Puppeteer, Playwright, Selenium) exactamente cuánto desplazar la palanca del deslizador.

Flujo de nodos

Copy 
Disparador de Programación (cada 1 hora) ─┐
                                 ├→ Configuración del Rompecabezas → Recuperar Imagen del Rompecabezas → Recuperar Imagen de Fondo
Disparador de Webhook (POST) ──────────┘    → Convertir Imágenes a Base64 → Resolver Rompecabezas de Deslizamiento
                                        → ¿Error de Deslizamiento? → Formatear Solución → Devolver Resultado
                                                        → Formatear Error → Devolver Error

Cómo Funciona

1. Disparadores Duplicados

  • Disparador de Programación: se ejecuta cada hora para pruebas automatizadas o resolución recurrente de rompecabezas
  • Disparador de Webhook: activación a petición desde otro flujo de trabajo o servicio externo

2. Configuración del Rompecabezas

Define las URLs para las imágenes de la pieza del rompecabezas y el fondo, más cualquier websiteURL opcional para mayor precisión. En una integración real, estas URLs provendrían de la respuesta del desafío de CAPTCHA del sitio objetivo.

3. Recuperar Imagen del Rompecabezas + Recuperar Imagen de Fondo

Dos nodos de Solicitud HTTP descargan las imágenes de la pieza del rompecabezas y el fondo como datos binarios.

4. Convertir Imágenes a Base64

Un nodo de Código convierte ambas imágenes binarias en cadenas base64 sin el prefijo data:image/...;base64,.

5. Resolver Rompecabezas de Deslizamiento

El nodo CapSolver con:

  • Recurso: Reconocimiento
  • Operación: Motor de Visión
  • módulo: slider_1
  • imagen: base64 de la pieza del rompecabezas
  • imagenFondo: base64 del fondo

Devuelve la distancia en píxeles de forma inmediata.

6. Verificar Resultado y Responder

El nodo IF comprueba los errores. En caso de éxito, se formatea y devuelve la solución. En caso de error, se devuelve el mensaje de error.

Respuesta Esperada

Éxito:

json Copy 
{
  "éxito": true,
  "módulo": "slider_1",
  "distancia": 142,
  "unidad": "píxeles",
  "resueltoEn": "2026-03-16T10:00:00.000Z"
}

Error:

json Copy 
{
  "éxito": false,
  "error": "ERROR_IMAGEN_NO_VÁLIDA",
  "resueltoEn": "2026-03-16T10:00:00.000Z"
}

Importar Este Flujo de Trabajo

Haga clic para expandir el JSON del flujo de trabajo
json Copy 
{
  "name": "Solucionador de Rompecabezas de Deslizamiento — Recuperar y Resolver — Motor de Visión",
  "nodes": [
    {
      "parameters": {
        "content": "## Solucionador de Rompecabezas de Deslizamiento — Recuperar y Resolver\n\n**¿Para quién es?** Equipos de automatización que resuelven CAPTCHAS de deslizamiento como parte de automatizaciones de navegadores o pipelines de raspado.\n\n**¿Qué hace?** Recupera una imagen de rompecabezas de deslizamiento y su fondo desde URLs, las convierte a base64, las envía al Motor de Visión de CapSolver (módulo slider_1) y devuelve la distancia exacta en píxeles para deslizar el control deslizante.\n\n**¿Cómo funciona?**\n1. Un disparador de Programación (cada 1h) o Webhook activa el flujo\n2. El nodo de configuración establece las URLs de las imágenes del rompecabezas\n3. Dos nodos de Solicitud HTTP recuperan las imágenes\n4. Un nodo de Código convierte las imágenes a base64\n5. El Motor de Visión de CapSolver resuelve el rompecabezas de deslizamiento\n6. Devuelve la distancia en píxeles para la automatización\n\n**Configuración:**\n1. Agregue su clave de API de CapSolver bajo **Configuración → Credenciales**\n2. Reemplace las URLs de imagen de ejemplo en Configuración del Rompecabezas\n3. Active y pruebe",
        "height": 560,
        "width": 460,
        "color": 1
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [-1200, -380],
      "id": "sticky-slider-main-001",
      "name": "Nota Adhesiva"
    },
    {
      "parameters": {
        "content": "### Disparadores\nProgramación (cada hora) o Webhook — ambos alimentan la misma pipeline de resolución de rompecabezas.",
        "height": 480,
        "width": 440,
        "color": 6
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [-860, -280],
      "id": "sticky-slider-section-002",
      "name": "Nota Adhesiva1"
    },
    {
      "parameters": {
        "content": "### Configuración del Rompecabezas\nEstablezca las URLs para las imágenes de la pieza del rompecabezas y el fondo. En producción, extraiga estas URLs de la respuesta del desafío del sitio objetivo.",
        "height": 480,
        "width": 440,
        "color": 6
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [-380, -280],
      "id": "sticky-slider-section-003",
      "name": "Nota Adhesiva2"
    },
    {
      "parameters": {
        "content": "### Recuperación de Imágenes\nDescargue ambas imágenes como datos binarios. La pieza del rompecabezas va en image, el fondo (con el espacio) va en imageBackground.",
        "height": 480,
        "width": 920,
        "color": 6
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [100, -280],
      "id": "sticky-slider-section-004",
      "name": "Nota Adhesiva3"
    },
    {
      "parameters": {
        "content": "### Conversión a Base64\nConvierte datos binarios de imagen a cadenas base64 sin el prefijo URI de datos. Ambas imágenes deben ser base64 sin formato para la API de CapSolver.",
        "height": 480,
        "width": 440,
        "color": 6
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [1060, -280],
      "id": "sticky-slider-section-005",
      "name": "Nota Adhesiva4"
    },
    {
      "parameters": {
        "content": "### Resolución con Motor de Visión + Manejo de Resultados\nCapSolver devuelve la distancia del deslizador de forma inmediata. El resultado se formatea y se devuelve mediante webhook o se almacena para su uso posterior.",
        "height": 480,
        "width": 1400,
        "color": 6
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [1540, -280],
      "id": "sticky-slider-section-006",
      "name": "Nota Adhesiva5"
    },
    {
      "parameters": {
        "rule": {
          "interval": [
            {
              "field": "hours",
              "hoursInterval": 1
            }
          ]
        }
      },
      "type": "n8n-nodes-base.scheduleTrigger",
      "typeVersion": 1.3,
      "position": [-820, -60],
      "id": "ve-slider-22222222-2222-2222-2222-222222222201",
      "name": "Cada 1 hora"
    },
    {
      "parameters": {
        "httpMethod": "POST",
        "path": "slider-puzzle-solver",
        "responseMode": "responseNode",
        "options": {}
      },
      "type": "n8n-nodes-base.webhook",
      "typeVersion": 2.1,
      "position": [-820, 140],
      "id": "ve-slider-22222222-2222-2222-2222-222222222202",
      "name": "Disparador de Webhook",
      "webhookId": "ve-slider-22222222-aaaa-bbbb-cccc-222222222202",
      "onError": "continueRegularOutput"
    },
    {
      "parameters": {
        "assignments": {
          "assignments": [
            {
              "id": "cfg-001",
              "name": "puzzleImageURL",
              "value": "={{ $json.body?.puzzleImageURL || 'https://example.com/captcha/puzzle-piece.png' }}",
              "type": "string"
            },
            {
              "id": "cfg-002",
              "name": "backgroundImageURL",
              "value": "={{ $json.body?.backgroundImageURL || 'https://example.com/captcha/background.png' }}",
              "type": "string"
            },
            {
              "id": "cfg-003",
              "name": "websiteURL",
              "value": "={{ $json.body?.websiteURL || '' }}",
              "type": "string"
            }
          ]
        },
        "options": {}
      },
      "type": "n8n-nodes-base.set",
      "typeVersion": 3.4,
      "position": [-340, 0],
      "id": "ve-slider-22222222-2222-2222-2222-222222222203",
      "name": "Configuración del Rompecabezas"
    },
    {
      "parameters": {
        "url": "={{ $json.puzzleImageURL }}",
        "options": {
          "response": {
            "response": {
              "responseFormat": "file"
            }
          }
        }
      },
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.3,
      "position": [140, -60],
      "id": "ve-slider-22222222-2222-2222-2222-222222222204",
      "name": "Recuperar Imagen del Rompecabezas"
    },
    {
      "parameters": {
        "url": "={{ $('Configuración del Rompecabezas').first().json.backgroundImageURL }}",
        "options": {
          "response": {
            "response": {
              "responseFormat": "file"
            }
          }
        }
      },
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.3,
      "position": [540, -60],
      "id": "ve-slider-22222222-2222-2222-2222-222222222205",
      "name": "Recuperar Imagen de Fondo"
    },
    {
      "parameters": {
        "jsCode": "// Obtener datos binarios de ambas recuperaciones de imagen\nconst puzzleBinary = $input.first().binary;\nconst config = $('Configuración del Rompecabezas').first().json;\n\nif (!puzzleBinary || !puzzleBinary.data) {\n  return [{ json: { error: 'Fallo al recuperar imagen del rompecabezas — no se devolvió datos binarios' } }];\n}\n\n// Convertir pieza del rompecabezas a base64\nconst puzzleBuffer = await this.helpers.getBinaryDataBuffer(0, 'data');\nconst puzzleBase64 = puzzleBuffer.toString('base64');\n\n// Obtener datos binarios de imagen de fondo desde la entrada del nodo actual\n// La imagen de fondo fue recuperada en el nodo anterior\nlet backgroundBase64 = '';\ntry {\n  const bgBinary = $input.first().binary;\n  if (bgBinary && bgBinary.data) {\n    const bgBuffer = await this.helpers.getBinaryDataBuffer(0, 'data');\n    backgroundBase64 = bgBuffer.toString('base64');\n  }\n} catch (e) {\n  // La imagen de fondo puede no estar disponible si la recuperación falló\n}\n\nreturn [{ json: {\n  image: puzzleBase64,\n  imageBackground: backgroundBase64,\n  websiteURL: config.websiteURL || '',\n  module: 'slider_1'\n} }];"
      },
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [1100, 0],
      "id": "ve-slider-22222222-2222-2222-2222-222222222206",
      "name": "Convertir Imágenes a Base64"
    },
    {
      "parameters": {
        "resource": "Reconocimiento",
        "operation": "Motor de Visión",
        "module": "={{ $json.module }}",
        "image": "={{ $json.image }}",
        "imageBackground": "={{ $json.imageBackground }}",
        "websiteURL": "={{ $json.websiteURL || '' }}"
      },
      "type": "n8n-nodes-capsolver.capSolver",
      "typeVersion": 1,
      "position": [1580, 0],
      "id": "ve-slider-22222222-2222-2222-2222-222222222207",
      "name": "Resolver Rompecabezas de Deslizamiento",
      "onError": "continueRegularOutput",
      "credentials": {
        "capSolverApi": {
          "id": "YOUR_CREDENTIAL_ID",
          "name": "Cuenta de CapSolver"
        }
      }
    },
    {
      "parameters": {
        "conditions": {
          "options": {
            "caseSensitive": true,
            "leftValue": "",
            "typeValidation": "loose",
            "version": 2
          },
          "conditions": [
            {
              "id": "slider-err-001",
              "leftValue": "={{ $json.error }}",
              "operator": {
                "type": "string",
                "operation": "isNotEmpty",
                "singleValue": true
              }
            }
          ],
          "combinator": "and"
        },
        "options": {}
      },
      "type": "n8n-nodes-base.if",
      "typeVersion": 2.2,
      "position": [1900, 0],
      "id": "ve-slider-22222222-2222-2222-2222-222222222208",
      "name": "¿Error de Deslizamiento?"
    },
    {
      "parameters": {
        "jsCode": "const solution = $input.first().json.data?.solution || $input.first().json.data || {};\nconst distance = solution.distance || solution.slide_distance || null;\n\nreturn [{ json: {\n  éxito: true,\n  módulo: 'slider_1',\n  distancia: distance,\n  unidad: 'píxeles',\n  soluciónBruta: solution,\n  resueltoEn: new Date().toISOString()\n} }];"
      },
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [2200, -80],
      "id": "ve-slider-22222222-2222-2222-2222-222222222209",
      "name": "Formatear Solución"
    },
    {
      "parameters": {
        "jsCode": "return [{ json: {\n  éxito: false,\n  error: $input.first().json.error || 'Error desconocido del Motor de Visión',\n  resueltoEn: new Date().toISOString()\n} }];"
      },
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [2200, 120],
      "id": "ve-slider-22222222-2222-2222-2222-222222222210",
{
    "name": "Error de formato"
    },
    {
      "parameters": {
        "respondWith": "json",
        "responseBody": "={{ JSON.stringify($json) }}",
        "options": {}
      },
      "type": "n8n-nodes-base.respondToWebhook",
      "typeVersion": 1.5,
      "position": [2500, -80],
      "id": "ve-slider-22222222-2222-2222-2222-222222222211",
      "name": "Devolver Resultado"
    },
    {
      "parameters": {
        "respondWith": "json",
        "responseBody": "={{ JSON.stringify($json) }}",
        "options": {
          "responseCode": 400
        }
      },
      "type": "n8n-nodes-base.respondToWebhook",
      "typeVersion": 1.5,
      "position": [2500, 120],
      "id": "ve-slider-22222222-2222-2222-2222-222222222212",
      "name": "Devolver Error"
    }
  ],
  "connections": {
    "Every 1 Hour": {
      "main": [
        [
          {
            "node": "Set Puzzle Config",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Webhook Trigger": {
      "main": [
        [
          {
            "node": "Set Puzzle Config",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Set Puzzle Config": {
      "main": [
        [
          {
            "node": "Fetch Puzzle Image",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Fetch Puzzle Image": {
      "main": [
        [
          {
            "node": "Fetch Background Image",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Fetch Background Image": {
      "main": [
        [
          {
            "node": "Convert Images to Base64",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Convert Images to Base64": {
      "main": [
        [
          {
            "node": "Solve Slider Puzzle",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Solve Slider Puzzle": {
      "main": [
        [
          {
            "node": "Slider Error?",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Slider Error?": {
      "main": [
        [
          {
            "node": "Format Error",
            "type": "main",
            "index": 0
          }
        ],
        [
          {
            "node": "Format Solution",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Format Solution": {
      "main": [
        [
          {
            "node": "Return Result",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Format Error": {
      "main": [
        [
          {
            "node": "Return Error",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  },
  "active": false,
  "settings": {
    "executionOrder": "v1"
  }
}
``

---

## Prueba

### Prueba de la API del Solucionador

Una vez que haya configurado las credenciales de CapSolver y activado el flujo de trabajo, pruebe la API del Solucionador:

**Puzzle de deslizamiento:**

```bash
curl -X POST https://your-n8n-instance.com/webhook/vision-engine-solver \
  -H "Content-Type: application/json" \
  -d '{
    "module": "slider_1",
    "image": "BASE64_PUZZLE_PIECE_HERE",
    "imageBackground": "BASE64_BACKGROUND_HERE"
  }'

Puzzle de rotación:

bash Copy 
curl -X POST https://your-n8n-instance.com/webhook/vision-engine-solver \
  -H "Content-Type: application/json" \
  -d '{
    "module": "rotate_1",
    "image": "BASE64_IMAGE_TO_ROTATE"
  }'

Selección de objetos (shein):

bash Copy 
curl -X POST https://your-n8n-instance.com/webhook/vision-engine-solver \
  -H "Content-Type: application/json" \
  -d '{
    "module": "shein",
    "image": "BASE64_IMAGE",
    "question": "Seleccionar todos los zapatos"
  }'

OCR de GIF:

bash Copy 
curl -X POST https://your-n8n-instance.com/webhook/vision-engine-solver \
  -H "Content-Type: application/json" \
  -d '{
    "module": "ocr_gif",
    "image": "BASE64_GIF_DATA"
  }'

Prueba del Solucionador de Puzzles de Deslizamiento

bash Copy 
curl -X POST https://your-n8n-instance.com/webhook/slider-puzzle-solver \
  -H "Content-Type: application/json" \
  -d '{
    "puzzleImageURL": "https://example.com/captcha/puzzle-piece.png",
    "backgroundImageURL": "https://example.com/captcha/background.png",
    "websiteURL": "https://example.com"
  }'

Una respuesta con un valor numérico distance confirma que todo el pipeline funcionó correctamente: las imágenes se descargaron, se convirtieron a base64, el Engine de Visión resolvió el deslizamiento y se devolvió la distancia en píxeles.

Entendiendo la Respuesta

El Engine de Visión devuelve formas de solución diferentes según el módulo:

slider_1

json Copy 
{
  "solution": {
    "distance": 142
  }
}

La distance está en píxeles: es la distancia que debe arrastrarse la palanca del deslizador hacia la derecha para completar el puzzle.

rotate_1 / rotate_2

json Copy 
{
  "solution": {
    "angle": 73
  }
}

El angle está en grados: es la cantidad en que debe rotarse la imagen (en sentido horario) para alcanzar la orientación correcta.

shein

json Copy 
{
  "solution": {
    "rects": [
      { "x1": 45, "y1": 120, "x2": 180, "y2": 250 },
      { "x1": 300, "y1": 90, "x2": 420, "y2": 210 }
    ]
  }
}

Cada rect en la matriz es un rectángulo de contorno (coordenadas de esquina superior izquierda y esquina inferior derecha) para un área coincidente en la imagen.

ocr_gif

json Copy 
{
  "solution": {
    "text": "x7Km9"
  }
}

El text es la cadena reconocida del GIF animado.

Adaptación para Otros Tipos de Módulos

El flujo de trabajo de la API del Solucionador ya admite los cinco módulos a través del cuerpo de la solicitud. Para construir un flujo de trabajo dedicado para un módulo diferente, por ejemplo, rotate_1 para puzzles de rotación, los cambios son mínimos:

  1. Nodo de configuración: Reemplazar puzzleImageURL / backgroundImageURL con solo la URL de la imagen de rotación
  2. Nodos de obtención: Solo se necesita una solicitud HTTP (no se necesita imagen de fondo para rotate_1)
  3. Nodo de CapSolver: Cambiar module a rotate_1
  4. Formato de solución: Extraer angle en lugar de distance

Para shein, también se agregaría el parámetro question al nodo de configuración y se pasaría al nodo de CapSolver.

Solución de Problemas

"ERROR_INVALID_IMAGE"

La cadena base64 está mal formada o vacía. Verifique que:

  • La imagen se haya obtenido correctamente (HTTP 200)
  • La conversión de binario a base64 produjo una cadena no vacía
  • Se haya eliminado el prefijo data:image/...;base64,
  • La cadena base64 no tenga saltos de línea ni espacios

"ERROR_INVALID_MODULE"

El valor de module no coincide con ningún modelo compatible. Use exactamente uno de: slider_1, rotate_1, rotate_2, shein, ocr_gif.

La distancia devuelve 0 o null

Las imágenes podrían no ser un par válido de puzzle de deslizamiento. Verifique que:

  • image sea la pieza del puzzle (el fragmento pequeño que se arrastra)
  • imageBackground sea el fondo completo con la ranura visible
  • Ambas imágenes sean del mismo instante del desafío
  • Las imágenes no estén corruptas o muy pequeñas

El nodo CapSolver no muestra la opción "Engine de Visión"

Asegúrese de tener la versión 1.x o posterior de n8n-nodes-capsolver. La operación Engine de Visión se agregó en versiones recientes. Actualice el nodo de la comunidad si es necesario:

  1. Vaya a Configuración > Nodos de la Comunidad
  2. Busque n8n-nodes-capsolver
  3. Actualice a la última versión
  4. Reinicie n8n

El webhook devuelve 404

El flujo de trabajo debe estar activo para que el webhook esté en línea. Importe el flujo de trabajo, configure las credenciales y active el flujo de trabajo en n8n.

Mejores Prácticas

  1. Use cadenas base64 sin procesar — siempre elimine el prefijo data:image/...;base64, antes de pasar las imágenes al nodo CapSolver.

  2. Asegúrese de que las imágenes coincidan con los módulos — slider_1 necesita tanto image como imageBackground. rotate_1 necesita solo image. shein necesita image más question. Usar combinaciones incorrectas fallará o devolverá resultados incorrectos.

  3. Obtenga imágenes frescas — las imágenes de puzzles visuales suelen ser de uso único y expiran rápidamente. Úselas lo más cercano posible al momento de resolver.

  4. El Engine de Visión es instantáneo — a diferencia de las operaciones de Token que realizan búsquedas por resultados, las operaciones de Reconocimiento devuelven resultados de inmediato. Su flujo de trabajo no necesita lógica de reintentos o retrasos.

  5. No se necesita proxy — el Engine de Visión analiza las imágenes en el servidor. No hay interacción con un sitio de destino, por lo que no se necesita proxy.

  6. Valide antes de resolver — verifique que los datos de imagen estén presentes y que el nombre del módulo sea válido antes de llamar al nodo CapSolver. Esto evita gastar créditos de API en solicitudes que fallarán.

  7. Use websiteURL cuando esté disponible — aunque es opcional, proporcionar la URL de la página de origen puede mejorar la precisión para algunos tipos de puzzles.

  8. Maneje respuestas específicas del módulo — diferentes módulos devuelven campos diferentes (distance, angle, rects, text). Su lógica posterior debe verificar qué módulo se usó y extraer el campo correcto.

¿Listo para comenzar? Regístrese en CapSolver y use el código de bonificación n8n para obtener un 8% adicional en su primer recarga!

Banner de código de bonificación de CapSolver

Conclusión

El Engine de Visión cubre un espacio diferente que las operaciones de Token de CapSolver. Mientras que la resolución de reCAPTCHA, Turnstile y Cloudflare Challenge devuelve tokens que usted envía para pasar una barrera, el Engine de Visión devuelve mediciones que su automatización usa para interactuar con puzzles visuales — arrastrar deslizadores, rotar imágenes, seleccionar objetos o leer texto animado.

Las diferencias clave a recordar son:

  • Recurso de Reconocimiento, no Token — resultados instantáneos, sin búsquedas
  • Imágenes en base64 en, mediciones fuera — píxeles, grados, coordenadas o texto
  • No se necesita proxy — la IA analiza las imágenes en el servidor
  • Cinco módulos — cada uno diseñado para un tipo específico de puzzle visual

Los dos flujos de trabajo en este artículo cubren los dos patrones de integración más comunes:

  1. API del Solucionador — un punto final de webhook genérico que acepta cualquier módulo y devuelve la solución
  2. Solucionador de Puzzles de Deslizamiento — un pipeline completo para puzzles de deslizamiento

Ambos se importan como inactivos. Configure su credencial de CapSolver, reemplace los valores de marcador de posición, active el flujo de trabajo y pruebe.

Preguntas Frecuentes

¿Cómo es diferente el Engine de Visión del OCR (reconocimiento óptico de caracteres)?

OCR reconoce caracteres en una imagen estática: reconocimiento óptico estándar. El Engine de Visión va más allá: entiende relaciones espaciales en puzzles visuales. Puede calcular distancias de deslizadores, ángulos de rotación, cuadros de contorno de objetos y hasta leer texto de GIFs animados. Ambos son operaciones de Reconocimiento (resultado instantáneo, sin búsquedas), pero resuelven problemas diferentes.

¿Necesito un proxy para el Engine de Visión?

No. El Engine de Visión analiza las imágenes que usted le proporciona en el servidor. No hay sesión de navegador, no hay cookies y no hay interacción con un sitio de destino. Los proxies no se necesitan y el nodo CapSolver no acepta un parámetro de proxy para tareas del Engine de Visión.

¿Puedo resolver múltiples puzzles en una ejecución del flujo de trabajo?

Sí. El nodo CapSolver procesa un elemento a la vez, pero la ejecución basada en elementos de n8n le permite pasar múltiples elementos al nodo. Cada elemento obtiene una llamada de Reconocimiento y devuelve su propia solución. Use un nodo de Dividir en Lotes o alimente múltiples elementos desde un nodo de Código.

¿Qué formatos de imagen se admiten?

Los campos image y imageBackground aceptan cadenas base64 codificadas en JPEG, PNG, GIF y WebP. La cadena base64 debe ser cruda — sin prefijo data:image/...;base64, ni saltos de línea.

¿Cómo obtengo las imágenes de puzzle de un sitio real?

En una integración real de puzzle de deslizamiento, el sitio objetivo sirve las imágenes de puzzle como parte de la respuesta del desafío. Normalmente usted:

  1. Cargará la página (a través de una solicitud HTTP o automatización de navegador)
  2. Extraerá las URLs de imagen del widget de CAPTCHA del DOM o de las solicitudes de red
  3. Obtendrá las imágenes
  4. Las convertirá a base64
  5. Las enviará al Engine de Visión

El flujo de trabajo del Solucionador de Puzzles de Deslizamiento muestra los pasos 3-5. Los pasos 1-2 dependen del sitio específico.

¿Qué hace el parámetro question?

El parámetro question solo se usa con el módulo shein. Le dice a la IA qué buscar en la imagen — por ejemplo, "Seleccionar todos los zapatos" o "Tocar los elementos coincidentes". Para todos los demás módulos, deje este campo vacío.

¿Puedo usar el Engine de Visión para desafíos de imagen de hCaptcha?

Los módulos del Engine de Visión (slider_1, rotate_1, rotate_2, shein, ocr_gif) están diseñados para tipos específicos de puzzles visuales. Los desafíos de clasificación de imagen de hCaptcha usan un enfoque diferente. Consulte la documentación de CapSolver para soluciones específicas de hCaptcha.

¿Qué tan rápido es el Engine de Visión?

El Engine de Visión es una operación de Reconocimiento, lo que significa que el resultado llega en una sola llamada de API — típicamente en menos de 2 segundos. No hay bucles de búsqueda, no hay llamadas a getTaskResult y no hay tiempos de espera. Esto lo hace significativamente más rápido que las operaciones de Token, que pueden tomar 10-30 segundos para completarse.

¿Qué sucede si la imagen es demasiado pequeña o demasiado grande?

Imágenes muy pequeñas pueden no contener suficiente detalle para un análisis preciso. Imágenes muy grandes aumentarán el tamaño del payload base64 y podrían ralentizar la solicitud. Para mejores resultados, use la resolución original proporcionada por el desafío de CAPTCHA — no redimensione las imágenes.

Sí, y ese es el caso de uso previsto para la mayoría de las aplicaciones reales. El flujo típico es:

  1. Automatización de navegador (Puppeteer/Playwright a través de n8n) carga la página
  2. Aparece el desafío de CAPTCHA con imágenes de puzzle
  3. Su flujo de trabajo extrae las URLs de imagen y las obtiene
  4. El Engine de Visión devuelve la solución (distancia, ángulo, etc.)
  5. La automatización de navegador usa la solución para completar el desafío (arrastrar el deslizador, rotar la imagen, hacer clic en coordenadas)

El flujo de trabajo del Engine de Visión maneja los pasos 3-4. Los pasos 1-2 y 5 se manejan por sus nodos de automatización de navegador.

Aviso de Cumplimiento: La información proporcionada en este blog es solo para fines informativos. CapSolver se compromete a cumplir con todas las leyes y regulaciones aplicables. El uso de la red de CapSolver para actividades ilegales, fraudulentas o abusivas está estrictamente prohibido y será investigado. Nuestras soluciones para la resolución de captcha mejoran la experiencia del usuario mientras garantizan un 100% de cumplimiento al ayudar a resolver las dificultades de captcha durante el rastreo de datos públicos. Fomentamos el uso responsable de nuestros servicios. Para obtener más información, visite nuestros Términos de Servicio y Política de Privacidad.

Máse

sCapSolver e integración de n8n para la resolución de CAPTCHA y automatización de flujos de trabajo
Cómo usar CapSolver en n8n: La guía completa para resolver CAPTCHA en tus flujos de trabajo

Aprende cómo integrar CapSolver con n8n para resolver CAPTCHAs y crear flujos de trabajo de automatización confiables con facilidad.

n8n
Logo of CapSolver

Adélia Cruz

18-Mar-2026

Resolver Acertijos visuales en n8n con CapSolver
Cómo resolver puzzles visuales en n8n con CapSolver

Resuelve CAPTCHAs visuales con el motor de visión de CapSolver en n8n. Maneja deslizadores, rotación, selección de objetos y OCR de GIF de forma inmediata.

n8n
Logo of CapSolver

Aloísio Vítor

18-Mar-2026

Resolver la huella de TLS en n8n con CapSolver
Cómo resolver el fingerprinting TLS en n8n con CapSolver

Resolver la huella dactilar TLS en n8n con CapSolver. Hacer que las solicitudes parezcan navegadores reales y evitar bloques de detección de bots.

n8n
Logo of CapSolver

Adélia Cruz

18-Mar-2026

Resolver Cloudflare Turnstile Usando CapSolver y n8n
Cómo resolver Cloudflare Turnstile usando CapSolver y n8n

Crea una API de resolución de Cloudflare Turnstile usando CapSolver y n8n. Aprende a automatizar la resolución de tokens, enviarlo a sitios web y extraer datos protegidos sin programación.

n8n
Logo of CapSolver

Adélia Cruz

10-Mar-2026