Cómo resolver CAPTCHA con Selenium en Ruby

Los CAPTCHA, o pruebas de Turing públicas completamente automatizadas para distinguir entre computadoras y humanos, están diseñados para proteger los sitios web de los bots automatizados. Si bien desempeñan un papel crucial en la seguridad de las plataformas en línea, pueden ser un obstáculo importante al automatizar tareas con herramientas como Selenium. Si está trabajando con Selenium en Ruby y necesita resolver CAPTCHA, esta guía le proporcionará un enfoque paso a paso para manejarlos de manera efectiva.

¿Qué son Selenium y Ruby?

Antes de sumergirnos en la resolución de CAPTCHA, es esencial comprender las herramientas con las que trabajará: Selenium y Ruby.

• Selenium es una poderosa herramienta de código abierto que se utiliza para automatizar los navegadores web. Permite a los desarrolladores escribir scripts en varios lenguajes de programación para simular interacciones del usuario con las páginas web, lo que lo convierte en una opción popular para las pruebas y el raspado web.
• Ruby es un lenguaje de programación dinámico y orientado a objetos conocido por su simplicidad y productividad. Se utiliza a menudo en el desarrollo web y, cuando se combina con Selenium, ofrece un marco robusto para automatizar tareas del navegador.

Comprender los CAPTCHA y sus tipos

Antes de sumergirse en la solución, es importante comprender los diferentes tipos de CAPTCHA que puede encontrar:

• CAPTCHA de ImageToText: Estos requieren que el usuario ingrese caracteres que se muestran en una imagen distorsionada. Puede encontrar algunos casos comunes aquí
• CAPTCHA basados en imágenes: Los usuarios deben seleccionar imágenes que coincidan con un criterio determinado (por ejemplo, seleccionar todas las imágenes con semáforos). Mayormente de reCAPTCHA
• reCAPTCHA: El sistema CAPTCHA avanzado de Google que a menudo requiere reconocer objetos en imágenes o simplemente hacer clic en una casilla de verificación para demostrar que no es un bot.

• captcha: Similar a reCAPTCHA, pero a menudo utilizado por sitios web que buscan soluciones más centradas en la privacidad.

Reclama tu Código de bonificación para las mejores soluciones de captcha; CapSolver: WEBS. Después de canjearlo, obtendrás un bono adicional del 5% después de cada recarga, ilimitado

¿Puede Selenium Ruby resolver CAPTCHAs?

Una de las preguntas más comunes entre los desarrolladores es si Selenium con Ruby puede resolver CAPTCHAs. La respuesta corta es: no directamente. Selenium solo no tiene capacidades incorporadas para resolver CAPTCHAs porque están diseñados específicamente para diferenciar entre usuarios humanos y bots.
Sin embargo, existen varios enfoques para manejar CAPTCHAs en Selenium Ruby:

1. Intervención manual: En algunos casos, los desarrolladores resuelven manualmente el CAPTCHA durante el proceso de automatización. Sin embargo, esto anula el propósito de la automatización completa.
2. Resolutor de CAPTCHA de terceros: El método más efectivo es integrar servicios de terceros como CapSolver que se especializan en resolver CAPTCHAs utilizando algoritmos avanzados e inteligencia humana.
3. Resolver CAPTCHAs simples: Para CAPTCHAs de texto muy básicos, los desarrolladores pueden escribir scripts personalizados para reconocer patrones, aunque este enfoque es limitado y a menudo poco confiable.

Si bien Selenium Ruby no puede resolver CAPTCHAs por sí solo, con las herramientas y servicios adecuados, es completamente posible automatizar el proceso de omitir CAPTCHAs, lo que exploraremos en esta guía.

Configurar Selenium en Ruby

Preparación

• Google Chrome: Instala la última versión del navegador Chrome, ya que utilizaremos código para interactuar con Chrome.
• Ruby: Asegúrate de que Ruby esté instalado en tu computadora.
• Selenium-webdriver: La biblioteca Ruby para la herramienta de automatización Selenium.
• CapSolver: La documentación oficial de CapSolver te ayudará a resolver los CAPTCHA.

Una vez que Ruby esté instalado en tu computadora, puedes instalar la biblioteca Selenium WebDriver ejecutando el comando gem install selenium-webdriver. Comprueba tu versión de Chrome y, en función de ella, descarga el controlador chromedriver.exe correspondiente. Puedes encontrar los enlaces de descarga en las siguientes ubicaciones:

• Enlace de descarga 1: Proporciona las últimas versiones Estables, Beta, Dev y Canary del controlador.
• Enlace de descarga 2: Proporciona todos los controladores desde la versión 113 en adelante.
• Enlace de descarga 3: Proporciona todos los controladores para versiones anteriores a la 113.

Analizando el sitio web objetivo

Usaremos el sitio web https://recaptcha-demo.appspot.com/recaptcha-v2-checkbox.php como ejemplo para resolver reCAPTCHA utilizando Ruby Selenium.

Antes de comenzar, necesitamos comprender los conceptos básicos del envío de formularios HTML. Observando esta página y abriendo las herramientas del desarrollador, podemos resolver manualmente el reCAPTCHA y luego hacer clic en el botón enviar. Esta acción envía una solicitud POST, enviando tres campos: ex-a, ex-b y g-recaptcha-response, como se muestra a continuación:

Estos tres campos corresponden a dos elementos de entrada y un elemento de área de texto dentro del formulario en el código fuente HTML inicial, como se muestra a continuación:

Automatizando el proceso con Ruby Selenium

¿Cómo podemos automatizar todo el proceso usando Ruby Selenium? Los pasos son los siguientes:

1. Ruby controla Selenium para visitar el sitio web objetivo.
2. Ruby llama a la API de CapSolver para resolver el reCAPTCHA y obtener un token.
3. Cambia el estilo CSS del elemento textarea de display: none a display: block para hacerlo interactivo con Selenium.
4. Simula la entrada del token devuelto por CapSolver en el elemento textarea.
5. Simula hacer clic en el botón de envío para enviar el formulario y completar la verificación.

Visitando el sitio web objetivo con Ruby Selenium

Asegúrate de reemplazar driver_path en el código a continuación con la ruta real a chromedriver en tu computadora.

require 'selenium-webdriver'

# Inicializa las opciones del navegador Chrome y accede al sitio web objetivo
driver_path = "path/to/chromedriver.exe"
options = Selenium::WebDriver::Chrome::Options.new
service = Selenium::WebDriver::Service.chrome(path: driver_path)
driver = Selenium::WebDriver.for :chrome, options: options, service: service
url = "https://recaptcha-demo.appspot.com/recaptcha-v2-checkbox.php"
driver.navigate.to url

Obteniendo el token

Para usar la API de CapSolver, necesitamos proporcionar la websiteKey, que se puede encontrar buscando la palabra clave data-sitekey en el código fuente de la página:

Ahora, escribamos el código Ruby para usar la API de CapSolver para resolver automáticamente el reCAPTCHA:

require 'net/http'
require 'json'
require 'time'

def cap_solver(api_key, public_key, page_url)
  payload = {
    "clientKey" => api_key,
    "task" => {
      "type" => 'ReCaptchaV2TaskProxyLess',
      "websiteKey" => public_key,
      "websiteURL" => page_url,
    }
  }

  # Envía una solicitud de creación de tarea

require 'selenium-webdriver'
require 'net/http'
require 'json'
require 'time'

def cap_solver(api_key, website_key, page_url)
  payload = {
    "clientKey" => api_key,
    "task" => {
      "type" => 'ReCaptchaV2TaskProxyLess',
      "websiteKey" => website_key,
      "websiteURL" => page_url,
    }
  }

  # Enviar una solicitud de creación de tarea
  uri = URI("https://api.capsolver.com/createTask")
  res = Net::HTTP.post(uri, payload.to_json, { "Content-Type" => "application/json" })
  resp = JSON.parse(res.body)
  task_id = resp["taskId"]

  unless task_id
    puts "Error al crear la tarea: #{res.body}"
    return
  end

  puts "Se obtuvo el taskId: #{task_id}"

  # Bucle esperando obtener los resultados de la tarea
  loop do
    sleep(1)
    payload = { "clientKey" => api_key, "taskId" => task_id }
    uri = URI("https://api.capsolver.com/getTaskResult")
    res = Net::HTTP.post(uri, payload.to_json, { "Content-Type" => "application/json" })
    resp = JSON.parse(res.body)
    status = resp["status"]
    if status == "ready"
      token = resp.dig("solution", "gRecaptchaResponse")
      puts "Resolución exitosa, token: #{token}"
      return token
    elsif status == "processing"
      puts "Resolución en progreso..."
    elsif status == "failed"
      puts "La resolución falló! respuesta: #{res.body}"
      return
    end
  end
end

# CapSolver API key (reemplácelo con su propia clave)
cap_solver_api_key = "su_clave_api_de_capsolver"
# Clave del sitio web (reemplácela con la clave del sitio web del sitio web objetivo)
website_key = "clave_del_sitio_web"
# URL de la página (reemplácela con la URL de la página objetivo)
page_url = "https://www.example.com"

# Obtenga el token de CapSolver
token = cap_solver(cap_solver_api_key, website_key, page_url)

# Establecer Selenium WebDriver
driver = Selenium::WebDriver.for :chrome
driver.get(page_url)

# Encontrar el elemento de entrada del token
token_input = driver.find_element(:id, "g-recaptcha-response")
token_input.send_keys(token)

# Hacer clic en el botón de envío (reemplácelo con el selector apropiado)
driver.find_element(:id, "submit_button").click

# Esperar a que se cargue la página (reemplácelo con la condición adecuada)
driver.wait_until { driver.find_element(:id, "success_message").displayed? }

# Imprimir un mensaje de éxito
puts "Se completó con éxito!"

# Cerrar el navegador
driver.quit

  sleep(1)
  payload = { "clientKey" => api_key, "taskId" => task_id }
  uri = URI("https://api.capsolver.com/getTaskResult")
  res = Net::HTTP.post(uri, payload.to_json, { "Content-Type" => "application/json" })
  resp = JSON.parse(res.body)
  status = resp["status"]
  if status == "ready"
    token = resp.dig("solution", "gRecaptchaResponse")
    puts "Solve succeed, token: #{token}"
    return token
  elsif status == "processing"
    puts "Solve in progress..."
  elsif status == "failed"
    puts "Solve failed! response: #{res.body}"
    return
  end
end

# Inicializa las opciones del navegador Chrome y accede al sitio web de destino
driver_path = "path/to/chromedriver.exe"
options = Selenium::WebDriver::Chrome::Options.new
service = Selenium::WebDriver::Service.chrome(path: driver_path)
driver = Selenium::WebDriver.for :chrome, options: options, service: service
url = "https://recaptcha-demo.appspot.com/recaptcha-v2-checkbox.php"
driver.navigate.to url

# Llama a la API de CapSolver para resolver ReCaptcha
cap_solver_api_key = 'YOUR_API_KEY'
website_key = '6LfW6wATAAAAAHLqO2pb8bDBahxlMxNdo9g947u9'
token = cap_solver(cap_solver_api_key, website_key, url)
if token.nil? || token.empty?
  puts "Fallo al resolver el captcha, presiona cualquier tecla para salir."
  STDIN.gets
  driver.quit
  return
end

# Cambia la propiedad de estilo de visualización del área de texto a bloque para que sea visible
driver.execute_script("document.getElementById('g-recaptcha-response').style.display = 'block';")
# Simula la introducción del token en el área de texto
textarea = driver.find_element(id: 'g-recaptcha-response')
textarea.send_keys(token)
# Simula el clic y el envío de un formulario
submit_btn = driver.find_element(css: "button[type='submit']")
submit_btn.click

puts "Presiona cualquier tecla para salir."
STDIN.gets
driver.quit

Más información

CapSolver utiliza tecnología de desbloqueo web automático basada en IA para ayudarte a resolver CAPTCHAs en segundos. Puede resolver no solo reCAPTCHA sino también captcha, captcha, Cloudflare Turnstile, captcha, captcha WAF y más. CapSolver también proporciona SDK en múltiples idiomas, así como extensiones de navegador. Puedes consultar la documentación de CapSolver para obtener más información.