Índice

Descargue los códigos de ejemplo basados en el cliente API:

Soporte de API de Recaptcha V3

¿Qué son los desafíos de "Recaptcha V3"?

reCAPTCHA v3 es una nueva medida de seguridad invisible introducida por Google. Agrega un captcha sin obligar al usuario a resolver ningún desafío. Utiliza un concepto llamado "acciones" para identificar el tráfico real del tráfico de bots.

Nuestro servicio ahora admite Google reCAPTCHA v3. Esta API es bastante similar a la API de tokens (reCAPTCHA v2). Solo se agregaron 2 nuevos parámetros, uno para la acción y otro para el puntaje mínimo.

Recaptcha V3 devuelve un puntaje de cada usuario, que evalúa si el usuario es un bot o humano. Luego, el sitio web utiliza el valor de puntuación que podría variar de 0 a 1 para decidir si aceptará o no las solicitudes. Los puntajes más bajos cerca de 0 se identifican como bot.

El parámetro action en Recaptcha V3 son datos adicionales utilizados para separar diferentes validaciones de CaptCha como por ejemplo Inicio de sesión, registro, ventas, etc..

Precios

Por el momento, el precio es $2.89/1K por desafíos de RECAPTCHA V3 resueltos correctamente. No se le facturará por Captchas reportados como resueltos incorrectamente. Tenga en cuenta que este precio se aplica solo a la nueva recaptcha v3, por lo que solo los clientes que usan esta API específica se cobrarán dicha tarifa.

Recaptcha V3 API Preguntas frecuentes:

¿Qué es la acción en Recaptcha V3?

Es un nuevo parámetro que permite procesar acciones de usuario en el sitio web de manera diferente.

Para encontrar esto, necesitamos inspeccionar el código JavaScript del sitio web que busca la llamada de grecaptcha.execute. Ejemplo:


grecaptcha.execute("6Lc2fhwTAAAAAGatXTzFYfvlQMI2T7B6ji8UVV_f", {action: something})
    

A veces es realmente difícil encontrarlo y necesitamos mirar a través de todos los archivos JavaScript. También podemos intentar encontrar el parámetro de valor de acción dentro del objeto de configuración ___grecaptcha_cfg. También podemos llamar al código de JavaScript e inspeccionar grecaptcha. La API utilizará el valor predeterminado "Verificar" si no proporcionaremos acciones en nuestra solicitud.

¿Qué es Min-Score en la API Recaptcha V3?

El puntaje mínimo necesario para la resolución del Captcha. Recomendamos usar el valor de 0.3, los puntajes mayores de 0.3 son difíciles de obtener.

¿Cuáles son los parámetros de POST para la API Recaptcha V3?
  • username: El nombre de usuario de su cuenta de DBC
  • password: La contraseña de su cuenta de DBC
  • type=5: Tipo 5 especifica que esto es Recaptcha V3 API
  • token_params=json(payload): los datos para acceder al desafío Recaptcha
  • Estructura de carga utilizando JSON:
    • proxy: Su url de proxy y credenciales (si las hay). Ejemplos:
      • http://127.0.0.1:3128
      • http://user:password@127.0.0.1:3128
    • proxytype: Su protocolo de conexión proxy. Para conocer los tipos de proxy compatibles, consulte ¿Qué tipos de proxy son compatibles?. Ejemplo:
      • HTTP
    • googlekey: La clave del sitio de Google Recaptcha del sitio web con Recaptcha. Para obtener más detalles sobre la clave del sitio, consulte ¿Qué es una clave de sitio de recaptcha? Ejemplo:
      • 6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-
    • pageurl: La URL de la página con los desafíos de Recaptcha. Esta URL debe incluir el camino en el que se carga la recaptcha. Ejemplo: si la recaptcha que desea resolver está en http://test.com/path1, Pageurl debe ser http://test.com/path1 y no http://test.com.
    • action: El nombre de la acción.
    • min_score: La puntuación mínima, generalmente 0.3
    El parámetro proxy es opcional, pero recomendamos encarecidamente usar uno para evitar el rechazo de la página proporcionada debido a inconsistencias entre la IP que resolvió el captcha (el nuestro si no se proporciona ningún proxy) y la IP que presentó la solución para la verificación (tuya).
    Nota: Si se proporciona proxy, proxytype es un parámetro requerido.

    Ejemplo completo de token_params:

    
    {
      "proxy": "http://127.0.0.1:3128",
      "proxytype": "HTTP",
      "googlekey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
      "pageurl": "http://test.com/path_with_recaptcha",
      "action": "example/action",
      "min_score": 0.3
    }
                
¿Cuál es la respuesta de recaptcha v3 api?

La respuesta tiene la misma estructura que una captcha regular. Consulte Consultar el estado de la CAPTCHA cargada para obtener detalles sobre la respuesta. La solución se encontrará en la clave texto de la respuesta. Es válido para un solo uso y tiene una duración de 1 minuto.

Ejemplos de código de uso de curl para la API Recaptcha V3:

1) Envíe su payload:

Tenga en cuenta que estamos usando type="5" para la API Recaptcha V3.

    curl --header 'Expect: ' -F username=your_username_here \
                             -F password=your_password_here \
                             -F type='5' \
                             -F token_params='{"proxy": "http://user:password@127.0.0.1:1234",
                                               "proxytype": "HTTP",
                                               "googlekey": "6Lc2fhwTAAAAAGatXTzFYfvlQMI2T7B6ji8UVV_b",
                                               "pageurl": "http://google.com",
                                               "action": "example/action",
                                               "min_score": 0.3}' \
                             http://api.dbcapi.me/api/captcha
        

2) Consultar Captcha: tome el CAPTCHA_ID dado y haga una solicitud como esta:
curl -H "Accept: application/json" http://api.dbcapi.me/api/captcha/CAPTCHA_ID
El resultado es una cadena JSON donde el campo "texto" incluye la solución respectiva:
'{"status": 0, "captcha": 2911096,
        "is_correct": true, "text": "textSolution"}'

Uso de la API recaptcha V3 con clientes API:


    # recaptcha_v3
    import deathbycaptcha
    import json

    # Put your DBC account username and password here.
    username = "username"
    password = "password"

    # you can use authtoken instead of user/password combination
    # activate and get the authtoken from DBC users panel
    authtoken = "authtoken"

    # to use socket client
    # client = deathbycaptcha.SocketClient(username, password)

    # to use authtoken
    # client = deathbycaptcha.SocketClient(username, password, authtoken)

    client = deathbycaptcha.HttpClient(username, password)

    # Put the proxy and recaptcha_v3 data
    # recaptcha_v3 requires 'action' that is the action that triggers
    # recaptcha_v3 validation
    # if 'action' isn't provided we use the default value "verify"
    # also you need to provide 'min_score', a number from 0.1 to 0.9,
    # this is the minimum score acceptable from recaptchaV3

    Captcha_dict = {
        'proxy': 'http://user:password@127.0.0.1:1234',
        'proxytype': 'HTTP',
        'googlekey': '6Lc2fhwTAAAAAGatXTzFYfvlQMI2T7B6ji8UVV_f',
        'pageurl': 'http://google.com',
        'action': "example/action",
        'min_score': 0.3}

    # Create a json string
    json_Captcha = json.dumps(Captcha_dict)

    try:
        balance = client.get_balance()
        print(balance)

        # Put your CAPTCHA type and Json payload here:
        captcha = client.decode(type=5, token_params=json_Captcha)
        if captcha:
            # The CAPTCHA was solved; captcha["captcha"] item holds its
            # numeric ID, and captcha["text"] item it's a list of "coordinates".
            print("CAPTCHA %s solved: %s" % (captcha["captcha"], captcha["text"]))

            if '':  # check if the CAPTCHA was incorrectly solved
                client.report(captcha["captcha"])
    except deathbycaptcha.AccessDeniedException:
        # Access to DBC API denied, check your credentials and/or balance
        print("error: Access to DBC API denied, check your credentials and/or balance")
      

Nuevo Recaptcha v2 con soporte de Token API

¿Qué son los desafíos de "Recaptcha V2"?

Son nuevos desafíos de recaptcha que generalmente requieren que el usuario identifique y haga clic en ciertas imágenes. No deben confundirse con los recaptchas de palabras/números tradicionales (esas no tienen imágenes).

Para su conveniencia, implementamos soporte para New Recaptcha de Token API. Si su software funciona con él y admite una configuración mínima, debería poder decodificar Captchas usando Death By Captcha en poco tiempo.

  • Token Image API: Proporcionó una URL y la clave del sitio, la API devuelve un token que usará para enviar el formulario en la página con el desafío RecaptCha.

También soportamos la resolución de Captchas tokens a través de nuestra 2captcha API . ¡Échale un vistazo!

Precios

Por el momento, el precio es $2.89/1K por desafíos de token recaptcha resueltos correctamente. No se le facturará por imágenes tokens reportadas como resueltas incorrectamente. Tenga en cuenta que este precio se aplica solo a las nuevas imágenes de recaptcha de token, por lo que solo los clientes que usan esta API específica se cobrarán dicha tarifa.

API de imagen de token Preguntas frecuentes:

¿Cuál es la URL de la API de imagen de token?

Para usar la API de imagen de token deberá enviar una solicitud de POST HTTP a http://api.dbcapi.me/api/captcha

¿Cuáles son los parámetros de POST para la API de imagen de token?

  • username: El nombre de usuario de su cuenta de DBC
  • password: La contraseña de su cuenta de DBC
  • type=4: Tipo 4 especifica que esta es una nueva API de imagen de token RECAPTCHA
  • token_params=json(payload): los datos para acceder al desafío Recaptcha
  • Estructura de carga utilizando JSON:
    • proxy: Su url de proxy y credenciales (si las hay). Ejemplos:
      • http://127.0.0.1:3128
      • http://user:password@127.0.0.1:3128
    • proxytype: Su protocolo de conexión proxy. Para conocer los tipos de proxy compatibles, consulte ¿Qué tipos de proxy son compatibles?. Ejemplo:
      • HTTP
    • googlekey: La clave del sitio de Google reCAPTCHA del sitio web con el reCAPTCHA. Para obtener más detalles sobre la clave del sitio, consulte ¿Qué es una clave de sitio de reCAPTCHA?. Ejemplo:
      • 6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-
    • pageurl: La URL de la página con los desafíos de Recaptcha. Esta URL debe incluir el camino en el que se carga la recaptcha. Ejemplo: si la recaptcha que desea resolver está en http://test.com/path1, Pageurl debe ser http://test.com/path1 y no http://test.com.

    • data-s: Este parámetro solo se requiere para resolver los tokens de búsqueda de Google, los visibles, mientras que Google Search activan la protección del robot. Use el valor de data-s dentro de la respuesta de búsqueda de Google HTML. Para los tokens habituales, no use este parámetro.
    El parámetro proxy es opcional, pero recomendamos encarecidamente usar uno para evitar el rechazo de la página proporcionada debido a inconsistencias entre la IP que resolvió el captcha (el nuestro si no se proporciona ningún proxy) y la IP que presentó la solución para la verificación (tuya).
    Nota: Si se proporciona proxy, proxytype es un parámetro requerido.

    Ejemplo completo de token_params:

    
    {
      "proxy": "http://127.0.0.1:3128",
      "proxytype": "HTTP",
      "googlekey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
      "pageurl": "http://test.com/path_with_recaptcha"
    }
                

¿Puedo resolver Recaptcha V2 en Google Search con Tokens API?

Google Search Captchas, los visibles, mientras que la búsqueda de Google activa la protección del robot. A partir de finales de mayo de 2020, ahora requieren un nuevo parámetro data-s para resolver esos captchas. En la búsqueda de Google, en el código HTML localice el valor data-s y envíelo como parte de token_params. Tenga en cuenta que el valor data-s solo se puede cargar una vez, evite cargar código JS en el formulario de Google Recaptcha. El parámetro data-s es único para cada captcha.

Ejemplo de token_params para Google Search Captchas:


{
  "googlekey": "6Le-wvkSA...",
  "pageurl": "...",
  "data-s": "IUdfh4rh0sd..."
}
            

¿Cuál es la respuesta de la API de imagen de token?

La respuesta de la API de la imagen del token tiene la misma estructura que la respuesta regular de Captcha. Consulte Consulta para el estado de CAPTCHA cargado para obtener detalles sobre la respuesta. El token vendrá en la clave texto de la respuesta. Es válido para un solo uso y tiene una duración de 2 minutos. Será una cadena como la siguiente:


       "03AOPBWq_RPO2vLzyk0h8gH0cA2X4v3tpYCPZR6Y4yxKy1s3Eo7CHZRQntxrd
        saD2H0e6S3547xi1FlqJB4rob46J0-wfZMj6YpyVa0WGCfpWzBWcLn7tO_EYs
        vEC_3kfLNINWa5LnKrnJTDXTOz-JuCKvEXx0EQqzb0OU4z2np4uyu79lc_Ndv
        L0IRFc3Cslu6UFV04CIfqXJBWCE5MY0Ag918r14b43ZdpwHSaVVrUqzCQMCyb
        cGq0yxLQf9eSexFiAWmcWLI5nVNA81meTXhQlyCn5bbbI2IMSEErDqceZjf1m
        X3M67BhIb4"

Para aprender a usar el token para resolver una recaptcha, consulte ¿Cómo usar el token para resolver una recaptcha?

¿Qué tipos de proxy son compatibles?

Actualmente, solo se admiten http proxies. El soporte para otros tipos se agregará en el futuro.

¿Qué es una clave de sitio de recaptcha?

Este es un identificador único que Google asigna a cada sitio web que utiliza el servicio Recaptcha. Para encontrar la clave del sitio, siga estos pasos:

  1. Vaya al sitio web cuya recaptcha está tratando de resolver.
  2. Abra la consola de desarrolladores de su navegador haciendo una de las siguientes opciones:
    • Use el atajo de teclado de su navegador (consulte este enlace para obtener ayuda)
    • Haga clic derecho en cualquier lugar de la página, haga clic en la opción "Inspeccionar" o "Inspeccionar elemento" y haga clic en la pestaña "Consola" de la ventana que se abre.
    • Si ninguno de los anteriores funciona, busque en Google cómo abrir la consola de su navegador.
  3. Pegue esta instrucción JavaScript en la consola de desarrolladores: document.getElementsByClassName('g-recaptcha')[0].getAttribute("data-sitekey");
  4. Presiona Enter. El resultado debería ser una cadena como la que se usa como ejemplo en la sección GoogleKey de la pregunta ¿Cuáles son los parámetros POST para la API de imágenes Token? Esta cadena es la clave del sitio.

No puedo encontrar data-sitekey, ¿qué puedo hacer?

Podemos encontrar el data-sitekey inspeccionando el elemento o viendo el código fuente de la página y buscar el nombre. data-sitekey localization example
Pero hay algunos casos en los que este data-sitekey no es obvio, en ese caso, intente buscar palabras similares o algunas cadenas que comiencen con 6L, no hay un método específico para encontrar el sitekey, en el caso de que sea críptico/duro- de obtener data-sitekey, necesitamos hacer uso de nuestras habilidades para obtenerlo.

¿Cómo usar un token para resolver una recaptcha?

Hay tres formas en que se puede usar el token:

El primer método consiste en hacer una solicitud POST a la URL en el atributo action del formulario con el token establecido como el valor del campo de texto cuyo id es g-recaptcha-response. Los otros campos pueden ser rellenados según se desee. Este es el método recomendado para consumir el token, dado que no requiere la emulación del navegador ni la manipulación del DOM.

La segunda forma es manipular el DOM. Si está desarrollando un script para resolver recaptchas, verifique si el lenguaje o el marco de programación que está utilizando tiene una biblioteca para manipular el DOM o ejecutar instrucciones de JavaScript. Los siguientes pasos deben completarse para usar con éxito el token:

  1. Coloque el token como el HTML interno del elemento con ID "g-recaptcha-response".
    • Para hacer esto con JavaScript, ejecuta: document.getElementById(`g-recaptcha-response`).innerHTML = TOKEN; donde TOKEN es la cadena devuelta en la clave text de la respuesta de la API. Coloque comillas dobles (") antes y después del token si la cadena devuelta aún no las tiene.
  2. Envíe el formulario o complete la acción que se requiere para que la recaptcha se resuelva.
    • Para lograr esto con JavaScript, ejecute: document.getElementById(`FORM_ID`).submit(); donde FORM_ID es la identificación del formulario que quiere ser enviado.
    • a veces no es suficiente solo enviar el formulario para resolver el recaptcha, en estos casos necesitamos copiar el token de resultado de la API al elemento G-Recaptcha-Response, teniendo cuidado de lidiar solo el token de resultado exacto y evitar el uso de espacios y otros caracteres como citas o citas dobles. Después de copiar el token de resultado en el elemento, necesitamos activar el evento de widget para que la captcha se marque como resuelta.
    • successfully solved reCAPTCHA
    • Cada sitio tiene una forma única de implementar la recaptcha, se recomienda hacer el proceso para un nuevo sitio manualmente antes de intentar automatizarlo, después de estar seguros de que todos los pasos para resolver el recaptcha podemos usar nuestras herramientas para automatizar el proceso. Tenemos en cuenta que a veces el formulario de envío activa el recaptcha, a veces no tenemos un formulario de envío o en otros casos es la devolución de llamada de Captcha que activa el evento para acceder a los recursos.
El último método para usar el token es enviando manualmente el formulario. Primero, siga los pasos 1 y 2 de la guía sobre cómo encontrar la clave del sitio especificada en ¿Qué es una clave de sitio reCAPTCHA?. Después de eso, copie la instrucción de JavaScript del paso 1 descrito anteriormente, péguela en la consola del desarrollador, presione enter y envíe manualmente el formulario.

Nota: Los métodos 2 y 3 solo deben usarse para fines de prueba, ya que son mucho más lentos y más intensivos en recursos que los primeros.

¿Cuál es la devolución de llamada Recaptcha?

Algunos sitios pueden configurar Recaptcha para dar una devolución de llamada en la validación exitosa y evitar el uso del envio del formulario, utilizando el atributo data-callback en la etiqueta G-Recaptcha o mediante el parámetro 'Callback` si se usa una representación explícita.

La función de devolución de llamada a menudo se define en el parámetro de data-callback de Recaptcha, por ejemplo:


        data-callback="myFunction";
      
O en algunos casos se define como el parámetro de devolución de llamada de la función grecaptcha.render, por ejemplo:


        grecaptcha.render('example', {
          'sitekey' : 'site-key',
          'callback' : myFunction
        });
      
Finalmente, todo lo que tenemos que hacer es llamar a esa función:

        myFunction();
      
Estoy usando el token que obtengo de la API ¿Por qué la recaptcha no está siendo resuelta?

Todos los sitios implementan el recaptcha a su manera, lo que significa que necesitamos analizar la implementación de recaptcha de cada sitio antes de intentar usar el token resultante. Una vez que estemos seguros de cómo funciona este sitio en particular, resolvemos el desafío reCAPTCHA como un usuario normal y obtenemos una comprensión de la implementación. Luego podemos comenzar a intentar usar manualmente el token resultante desde la API y después de estar seguros del procedimiento, podemos automatizarlo. Para estar seguro de cómo funciona recaptcha, podemos echar un vistazo a la documentación reCAPTCHA v2.

¿Cómo verificar que mi proxy se esté utilizando para resolver un captcha?

Vaya a Subidas anteriores después de subir una captcha y consulte los campos de "proxy" y "estado de proxy" de la captcha cargada. Si su proxy se usó para resolver el CaptCha, el valor del campo "proxy" será la dirección IP de su proxy y el "estado proxy proporcionado" será "bueno". Si no se usó, "proxy" tendrá "proxy DBC" como valor (lo que significa que Captcha se resolvió utilizando uno de nuestros proxies) y el valor del campo "Provided Proxy Status" será "malo o no proporcionado". Captura de pantalla de ejemplo:

Example screenshot of Provided Proxy Status in Previous Submissions section

Ejemplos de código de uso para la API de imagen token:

1) Envíe su payload:

Tenga en cuenta que estamos usando type="4" para la API de imagen de token.

    curl --header 'Expect: ' -F username=your_username_here \
                             -F password=your_password_here \
                             -F type='4' \
                             -F token_params='{"proxy": "http://user:password@127.0.0.1:1234",
                                               "proxytype": "HTTP",
                                               "googlekey": "6Lc2fhwTAAAAAGatXTzFYfvlQMI2T7B6ji8UVV_b",
                                               "pageurl": "http://google.com"}' \
                             http://api.dbcapi.me/api/captcha
        

2) Consultar Captcha: tome el CAPTCHA_ID dado y haga una solicitud como esta:
curl -H "Accept: application/json" http://api.dbcapi.me/api/captcha/CAPTCHA_ID
El resultado es una cadena JSON donde el campo "texto" incluye la solución respectiva:
'{"status": 0, "captcha": 2911096,
        "is_correct": true, "text": "textToken"}'

Uso de la API de imagen de token con clientes API:


    /**
     * Death by Captcha PHP API recaptcha_v2 usage example
     *
     * @package DBCAPI
     * @subpackage PHP
     */

    /**
     * DBC API clients
     */
    require_once '../deathbycaptcha.php';

    $username = "username";  // DBC account username
    $password = "password";  // DBC account password
    $token_from_panel = "your-token-from-panel";  // DBC account authtoken

    // Use DeathByCaptcha_SocketClient() class if you want to use SOCKET API.
    $client = new DeathByCaptcha_HttpClient($username, $password);
    $client->is_verbose = true;

    // To use token the first parameter must be authtoken.
    // $client = new DeathByCaptcha_HttpClient("authtoken", $token_from_panel);

    echo "Your balance is {$client->balance} US cents\n";

    // To use recaptcha_Token
    // Set the proxy and reCaptcha token data
    $data = array(
         'proxy' => 'http://user:password@127.0.0.1:1234',
         'proxytype' => 'HTTP',
        'googlekey' => '6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-',
        'pageurl' => 'https://www.google.com/recaptcha/api2/demo'
    );
    //Create a json string
    $json = json_encode($data);

    //Put the type and the json payload
    $extra = [
        'type' => 4,
        'token_params' => $json,
    ];

    // Put null the first parameter and add the extra payload
    if ($captcha = $client->decode(null, $extra)) {
        echo "CAPTCHA {$captcha['captcha']} uploaded\n";

        sleep(DeathByCaptcha_Client::DEFAULT_TIMEOUT);

        // Poll for CAPTCHA indexes:
        if ($text = $client->get_text($captcha['captcha'])) {
            echo "CAPTCHA {$captcha['captcha']} solved: {$text}\n";

            // Report an incorrectly solved CAPTCHA.
            // Make sure the CAPTCHA was in fact incorrectly solved!
            //$client->report($captcha['captcha']);
        }
    }
        

    import deathbycaptcha
    import json

    # Put your DBC account username and password here.
    username = "username"
    password = "password"

    # you can use authtoken instead of user/password combination
    # activate and get the authtoken from DBC users panel
    authtoken = "authtoken"

    # to use socket client
    # client = deathbycaptcha.SocketClient(username, password)

    # to use authtoken
    # client = deathbycaptcha.SocketClient(username, password, authtoken)

    client = deathbycaptcha.HttpClient(username, username)

    # Put the proxy and recaptcha_v2 data
    Captcha_dict = {
        'proxy': 'http://user:password@127.0.0.1:1234',
        'proxytype': 'HTTP',
        'googlekey': '6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-',
        'pageurl': 'https://www.google.com/recaptcha/api2/demo'}
    # Create a json string
    json_Captcha = json.dumps(Captcha_dict)

    try:
        balance = client.get_balance()
        print(balance)

        # Put your CAPTCHA type and Json payload here:
        captcha = client.decode(type=4, token_params=json_Captcha)
        if captcha:
            # The CAPTCHA was solved; captcha["captcha"] item holds its
            # numeric ID, and captcha["text"] item it's a text token".
            print("CAPTCHA %s solved: %s" % (captcha["captcha"], captcha["text"]))

            if '':  # check if the CAPTCHA was incorrectly solved
                client.report(captcha["captcha"])
    except deathbycaptcha.AccessDeniedException:
        # Access to DBC API denied, check your credentials and/or balance
        print("error: Access to DBC API denied, check your credentials and/or balance")


        

import com.DeathByCaptcha.AccessDeniedException;
import com.DeathByCaptcha.Client;
import com.DeathByCaptcha.HttpClient;
import com.DeathByCaptcha.SocketClient;
import com.DeathByCaptcha.Captcha;
import org.json.JSONObject;

import java.io.IOException;

class ExampleRecaptchaV2 {
    public static void main(String[] args)
            throws Exception {

        // Put your DBC username & password or authtoken here:
        String username = "your_username_here";
        String password = "your_password_here";
        String authtoken = "your_authtoken_here";

        /* Death By Captcha Socket Client
           Client client = (Client) (new SocketClient(username, password));
           Death By Captcha http Client */
        Client client = (Client) (new HttpClient(username, password));
        client.isVerbose = true;

        /* Using authtoken
           Client client = (Client) new HttpClient(authtoken); */

        try {
            try {
                System.out.println("Your balance is " + client.getBalance() + " US cents");
            } catch (IOException e) {
                System.out.println("Failed fetching balance: " + e.toString());
                return;
            }

            Captcha captcha = null;
            try {
                // Proxy and reCAPTCHA v2 token data
                String proxy = "http://user:password@127.0.0.1:1234";
                String proxytype = "http";
                String googlekey = "6Lc2fhwTAAAAAGatXTzFYfvlQMI2T7B6ji8UVV_f";
                String pageurl = "http://google.com";
                /* Upload a reCAPTCHA v2 and poll for its status with 120 seconds timeout.
                   Put the token params and timeout (in seconds)
                   0 or nothing for the default timeout value. */
                captcha = client.decode(proxy, proxytype, googlekey, pageurl);

                //other method is to send a json with the parameters
                /*
                JSONObject json_params = new JSONObject();
                json_params.put("proxy", proxy);
                json_params.put("proxytype", proxytype);
                json_params.put("googlekey", googlekey);
                json_params.put("pageurl", pageurl);
                captcha = client.decode(4, json_params);
                */
            } catch (IOException e) {
                System.out.println("Failed uploading CAPTCHA");
                return;
            }

            if (null != captcha) {
                System.out.println("CAPTCHA " + captcha.id + " solved: " + captcha.text);

                // Report incorrectly solved CAPTCHA if necessary.
                // Make sure you've checked if the CAPTCHA was in fact incorrectly
                // solved, or else you might get banned as abuser.
                /*try {
                    if (client.report(captcha)) {
                        System.out.println("Reported as incorrectly solved");
                    } else {
                        System.out.println("Failed reporting incorrectly solved CAPTCHA");
                    }
                } catch (IOException e) {
                    System.out.println("Failed reporting incorrectly solved CAPTCHA: " + e.toString());
                }*/
            } else {
                System.out.println("Failed solving CAPTCHA");
            }
        } catch (com.DeathByCaptcha.Exception e) {
            System.out.println(e);
        }


    }
}
        

using System;
using System.Collections;
using DeathByCaptcha;

namespace DBC_Examples.examples
{
    public class RecaptchaV2Example
    {
        public void Main()
        {
            // Put your DeathByCaptcha account username and password here.
            string username = "your username";
            string password = "your password";
            // string token_from_panel = "your-token-from-panel";

            /* Death By Captcha Socket Client
               Client client = (Client) new SocketClient(username, password);
               Death By Captcha http Client */
            Client client = (Client) new HttpClient(username, password);

            /* To use token authentication the first parameter must be "authtoken".
            Client client = (Client) new HttpClient("authtoken", token_from_panel); */

            // Put your Proxy credentials and type here
            string proxy = "http://user:password@127.0.0.1:1234";
            string proxyType = "HTTP";
            string googlekey = "6Lc2fhwTAAAAAGatXTzFYfvlQMI2T7B6ji8UVV_b";
            string pageurl = "http://google.com";

            string tokenParams = "{\"proxy\": \"" + proxy + "\"," +
                                 "\"proxytype\": \"" + proxyType + "\"," +
                                 "\"googlekey\": \"" + googlekey + "\"," +
                                 "\"pageurl\": \"" + pageurl + "\"}";

            try
            {
                double balance = client.GetBalance();

                /* Upload a CAPTCHA and poll for its status.  Put the Token CAPTCHA
                   Json payload, CAPTCHA type and desired solving timeout (in seconds)
                   here. If solved, you'll receive a DeathByCaptcha.Captcha object. */
                Captcha captcha = client.Decode(Client.DefaultTimeout,
                    new Hashtable()
                    {
                        {"type", 4},
                        {"token_params", tokenParams}
                    });

                if (null != captcha)
                {
                    /* The CAPTCHA was solved; captcha.Id property holds
                    its numeric ID, and captcha.Text holds its text. */
                    Console.WriteLine("CAPTCHA {0} solved: {1}", captcha.Id,
                        captcha.Text);

//                  if ( /* check if the CAPTCHA was incorrectly solved */)
//                  {
//                      client.Report(captcha);
//                  }
                }
            }
            catch (AccessDeniedException e)
            {
                /* Access to DBC API denied, check your credentials and/or balance */
                Console.WriteLine("<<< catch : " + e.ToString());
            }
        }
    }
}
         

Imports DeathByCaptcha

Public Class RecaptchaV2
    Sub Main(args As String())

        ' Put your DBC username & password or authtoken here:
        Dim username = "username"
        Dim password = "password"
        Dim token_from_panel = "your-token-from-panel"

        ' DBC Socket API client
        ' Dim client As New SocketClient(username, password)
        ' DBC HTTP API client
        Dim client As New HttpClient(username, password)

        ' To use token auth the first parameter must be "authtoken"
        ' Dim client As New HttpClient("authtoken", token_from_panel)

        ' Proxy and recaptcha_v2 token data
        Dim proxy = "http://user:password@127.0.0.1:1234"
        Dim proxyType = "HTTP"
        Dim googlekey = "6Lc2fhwTAAAAAGatXTzFYfvlQMI2T7B6ji8UVV_b"
        Dim pageurl = "http://google.com"

        Console.WriteLine(String.Format("Your balance is {0,2:f} US cents",
                                        client.Balance))

        ' Create a JSON with the extra data
        Dim tokenParams = "{""proxy"": """ + proxy + """," +
                          """proxytype"": """ + proxyType + """," +
                          """googlekey"": """ + googlekey + """," +
                          """pageurl"": """ + pageurl + """}"

        '  Create the payload with the type and the extra data
        Dim extraData As New Hashtable()
        extraData.Add("type", 4)
        extraData.Add("token_params", tokenParams)

        ' Upload a CAPTCHA and poll for its status.  Put the Token CAPTCHA
        ' Json payload, CAPTCHA type and desired solving timeout (in seconds)
        ' here. If solved, you'll receive a DeathByCaptcha.Captcha object.
        Dim captcha As Captcha = client.Decode(DeathByCaptcha.Client.DefaultTimeout, extraData)
        If captcha IsNot Nothing Then
            Console.WriteLine(String.Format("CAPTCHA {0:d} solved: {1}", captcha.Id,
                                            captcha.Text))

            ' Report an incorrectly solved CAPTCHA.
            ' Make sure the CAPTCHA was in fact incorrectly solved, do not
            ' just report it at random, or you might be banned as abuser.
            ' If client.Report(captcha) Then
            '    Console.WriteLine("Reported as incorrectly solved")
            ' Else
            '    Console.WriteLine("Failed reporting as incorrectly solved")
            ' End If
        End If
    End Sub
End Class


' this script uses DeCaptcher API, to use this API first we need to opt-in our user
' in the following URL http://deathbycaptcha.com/user/api/decaptcher
' Is recomended to read the FAQ in that page

' this script can use authentication token instead of username/password combination
' to use this API with authentication token, first we need enable token authentication
' on users panel authentication on users panel when using authentication token the username
' must be the keyword authtoken and the password is the authentication token from users panel

VERSION BUILD=844
' we need to set a timeout to wait for the captcha solution
SET !TIMEOUT_PAGE 200
' the script go to this URL to use the API
URL GOTO=http://api.dbcapi.me/decaptcher?function=token&print_format=html
' Set our username, need to replace {{}} with username, ex.
' TAG POS=1 TYPE=INPUT:TEXT FORM=ACTION:http://api.dbcapi.me/decaptcher
'                             ATTR=NAME:username CONTENT=myusername
TAG POS=1 TYPE=INPUT:TEXT FORM=ACTION:http://api.dbcapi.me/decaptcher
                                ATTR=NAME:username CONTENT={{username}}
' replace password with our password, ex.
' TAG POS=1 TYPE=INPUT:TEXT FORM=ACTION:http://api.dbcapi.me/decaptcher
'                           ATTR=NAME:password CONTENT=mycurrentpassword
TAG POS=1 TYPE=INPUT:TEXT FORM=ACTION:http://api.dbcapi.me/decaptcher
                            ATTR=NAME:password CONTENT={{password}}
' here we set our proxy, ex.
' TAG POS=1 TYPE=INPUT:TEXT FORM=ACTION:http://api.dbcapi.me/decaptcher
'    ATTR=NAME:proxy CONTENT=https://proxy_username:proxy_password@proxy_url:proxy_port
' we need to use this proxy format https://proxy_username:proxy_password@proxy_url:proxy_port
TAG POS=1 TYPE=INPUT:TEXT FORM=ACTION:http://api.dbcapi.me/decaptcher
                                            ATTR=NAME:proxy CONTENT={{proxy}}
' here we set the proxy type ex.
' TAG POS=1 TYPE=INPUT:TEXT FORM=ACTION:http://api.dbcapi.me/decaptcher
'                                           ATTR=NAME:proxytype CONTENT=http
TAG POS=1 TYPE=INPUT:TEXT FORM=ACTION:http://api.dbcapi.me/decaptcher ATTR=NAME:proxytype
                                                                        CONTENT={{proxy_type}}
' here we set the googlekey
' for information about googlekey, look here
' http://deathbycaptcha.com/user/api/newtokenrecaptcha#what-site-key
TAG POS=1 TYPE=INPUT:TEXT FORM=ACTION:http://api.dbcapi.me/decaptcher ATTR=NAME:googlekey
                                                                CONTENT={{google_site_key}}
' here we set the site that have the token recaptcha challenge, ex.
' TAG POS=1 TYPE=INPUT:TEXT FORM=ACTION:http://api.dbcapi.me/decaptcher ATTR=NAME:pageurl
                                                        CONTENT=https://www.site.com/login
TAG POS=1 TYPE=INPUT:TEXT FORM=ACTION:http://api.dbcapi.me/decaptcher ATTR=NAME:pageurl
                                                                CONTENT={{challenge_site}}
' we submit the captcha to solve
TAG POS=1 TYPE=INPUT:SUBMIT FORM=ACTION:http://api.dbcapi.me/decaptcher ATTR=VALUE:Send

' and we get our result
TAG POS=6 TYPE=TD ATTR=* EXTRACT=TXT
SET !VAR1 {{!EXTRACT}}


/*
* Death by Captcha Node.js API recaptcha_v2 token image usage example
*/

const dbc = require('../deathbycaptcha');

const username = 'username';     // DBC account username
const password = 'password';     // DBC account password
const token_from_panel = 'your-token-from-panel';   // DBC account authtoken

// Proxy and recaptcha_v2 token data
const token_params = JSON.stringify({
    'proxy': 'http://username:password@proxy.example:3128',
    'proxytype': 'HTTP',
    'googlekey': '6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-',
    'pageurl': 'https://www.google.com/recaptcha/api2/demo'
});

// Death By Captcha Socket Client
// const client = new dbc.SocketClient(username, password);
// Death By Captcha http Client
const client = new dbc.HttpClient(username, password);

// To use token authentication the first parameter must be "authtoken"
// const client = new dbc.HttpClient("authtoken", token_from_panel);

// Get user balance
client.get_balance((balance) => {
    console.log(balance);
});

// Solve captcha with type 4 & token_params extra arguments
client.decode({extra: {type: 4, token_params: token_params}}, (captcha) => {

    if (captcha) {
        console.log('Captcha ' + captcha['captcha'] + ' solved: ' + captcha['text']);

        /*
        * Report an incorrectly solved CAPTCHA.
        * Make sure the CAPTCHA was in fact incorrectly solved!
        * client.report(captcha['captcha'], (result) => {
        *   console.log('Report status: ' + result);
        * });
        */
    }

});

        

Estado: OK

Los servidores están completamente operativos con un tiempo de respuesta más rápido que el promedio.
  • Tiempo medio de resolución
  • 4 segundos - Normal CAPTCHAs (1 min. atrás)
  • 29 segundos - reCAPTCHA V2, V3, etc (1 min. atrás)
  • 14 segundos - hCAPTCHA & otros (1 min. atrás)
Chrome and Firefox logos
Extensiones de navegador disponibles

Actualizaciones

  1. Feb 26: NEW TYPE ADDED - Now supporting Friendly CAPTCHA!! See the details at https://deathbycaptcha.com/api/friendly
  2. Nov 22: Now supporting Amazon WAF!! See the details at https://deathbycaptcha.com/api/amazonwaf
  3. Nov 01: Today our Socket API was affected by a technical issue for a few hours. It's now sorted and back to 100%, working optimally. We sincerely apologize for the inconvenience this may have caused you. If you were affected, please don't hesitate to contact us: https://deathbycaptcha.com/contact and we'll be happy to assist/compensate you!

  4. Actualizaciones anteriores…

Apoyo

Nuestro sistema está diseñado para ser completamente fácil de usar. Si tiene algún problema con él, simplemente envíenos un correo electrónico a Correo electrónico de soporte técnico de DBC com, y un agente de soporte se comunicará con usted lo antes posible.

Soporte en vivo

Disponible de lunes a viernes (10 am a 4 pm EST) Live support image. Link to live support page