Indice

• Python

    # 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")
      

Nouveau Recaptcha v2 avec prise en charge de Token API

Que sont les défis « Recaptcha V2 » ?

Ce sont de nouveaux défis Recaptcha qui nécessitent généralement que l'utilisateur s'identifie et clique sur certaines images. Ils ne sont pas confondus avec les recaptchas de mots / nombres traditionnels (ceux-ci n'ont pas d'images).

Pour votre commodité, nous avons mis en œuvre la prise en charge de la nouvelle RecaptCha par API Token. Si votre logiciel fonctionne avec lui et prend en charge une configuration minimale, vous devriez être en mesure de décoder les captchas en utilisant Death By CaptCha en un rien de temps.

• Token Image API: Fourni d'une URL du site et d'une clé de site, l'API renvoie un jeton que vous utiliserez pour soumettre le formulaire dans la page avec le défi RecaptCha.

Nous soutenons également la résolution de captchas de jetons via notre 2captcha api . Vérifiez-le!

Prix

Pour le moment, le prix est de $2,89/1k que les défis RECAPTCHA sont correctement résolus. Vous ne serez pas facturé pour des images de jetons signalées comme résolues incorrectement. Notez que ce prix s'applique uniquement aux nouvelles images RecaptCha token, de sorte que seuls les clients utilisant cette API spécifique seront facturés par ce taux.

API Image de jeton FAQ:

Quelle est l'URL de l'API d'image de jeton Token Image API URL?

Pour utiliser l'API d'image de jeton, vous devrez envoyer une demande de message HTTP à http://api.dbcapi.me/api/captcha

Quels sont les paramètres de poste de l'API d'image de jeton ?

• username: Votre nom d'utilisateur de compte DBC
• password: Votre mot de passe du compte DBC
• type=4: Type 4 Spécifie qu'il s'agit d'une nouvelle API Image de jeton RECAPTCHA
• token_params=json(payload): les données pour accéder au défi Recaptcha
Structure de la charge utile JSON:
• proxy: Votre URL et références proxy (le cas échéant). Exemples:
  • http://127.0.0.1:3128
  • http://user:password@127.0.0.1:3128
• proxytype: Votre protocole de connexion proxy. Pour savoir quels types de proxy sont pris en charge, consultez Quels sont les types de proxy pris en charge ? Exemple :
  • HTTP
• googlekey: La clé de site Google reCAPTCHA du site web avec le reCAPTCHA. Pour plus de détails sur la clé de site, reportez-vous à Qu`est-ce qu`une clé de site reCAPTCHA?. Exemple :
  • 6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-
• pageurl: L'URL de la page avec les défis Recaptcha. Cette URL doit inclure le chemin dans lequel le recaptcha est chargé. Exemple: Si le recaptcha que vous souhaitez résoudre est dans http://test.com/path1, Pageurl doit être http://test.com/path1 et non http://test.com.


• data-s: Ce paramètre n'est requis que pour résoudre les jetons de recherche Google, ceux visibles, tandis que Google Search déclenche la protection du robot. Utilisez la valeur Data-S dans la réponse de recherche Google HTML. Pour les jetons réguliers, n'utilisez pas ce paramètre.
Le paramètre proxy est facultatif, mais nous recommandons fortement d'en utiliser un pour empêcher le rejet par la page fournie en raison d'incohérences entre l'IP qui a résolu le captcha (le nôtre si aucun proxy n'est fourni) et l'IP soumis La solution de vérification (la vôtre).
Remarque: Si le proxy est fourni, proxytype est un paramètre requis.



Exemple complet de token_params:

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

Vous ne pouvez pas résoudre RecaptCha V2 sur Google Search avec API Tokens?

Google Search Captchas, ceux visibles, tandis que Google Search déclenche la protection du robot. À partir de la fin du mois de mai 2020, nécessite désormais un nouveau paramètre data-s pour résoudre ces captchas. Dans la recherche Google Recherche RecaptCha, le code HTML localise la valeur data-s et envoyez-les dans le cadre de token_params. Notez que la valeur data-s ne peut être chargée qu'une seule fois, évitez de charger le code JS au formulaire Google Recaptcha. Le paramètre data-s est unique pour chaque captcha.

Exemple de token_params pour Google Search capchas:

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

Quelle est la réponse de l'API d'image de jeton?

La réponse de l`API d`image de jeton a la même structure que la réponse d`une captcha ordinaire. Référez-vous à sondage pour le statut du CAPTCHA chargé pour plus de détails sur la réponse. Le jeton sera dans la clé texte de la réponse. Il est valide pour une utilisation et a une durée de vie de 2 minutes. Il sera sous la forme d`une chaîne de caractères comme suit :

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

Pour apprendre à utiliser le jeton pour résoudre un recaptcha, veuillez vous référer à Comment utiliser le jeton pour résoudre un recaptcha?

Quels types de proxy sont pris en charge?

Actuellement, seuls les proxys http sont pris en charge. La prise en charge d'autres types sera ajoutée à l'avenir.

Qu'est-ce qu'une clé de site Recaptcha?

Il s'agit d'un identifiant unique que Google attribue à chaque site Web qui utilise le service RecaptCha. Pour trouver la clé du site, suivez ces étapes:

1. Allez sur le site Web dont vous essayez de contourner.
2. Ouvrez la console des développeurs de votre navigateur en faisant l'un des éléments suivants:
   • Utilisez le raccourci clavier de votre navigateur (reportez-vous à ce lien pour obtenir de l`aide)
   • Cliquez avec le bouton droit n'importe où sur la page, cliquez sur l'option "Inspecter" ou "Inspectez l'élément" et cliquez sur l'onglet "Console" de la fenêtre ouverte.
   • Si aucun des éléments ci-dessus ne fonctionne, recherchez sur Google comment ouvrir la console de votre navigateur.
3. Collez cette instruction JavaScript sur la console des développeurs : document.getElementsByClassName('g-recaptcha')[0].getAttribute("data-sitekey");
4. Appuyez sur Entrée. Le résultat devrait être une chaîne comme celle utilisée comme exemple dans la section Googlekey de la question Quels sont les paramètres POST pour l`API d`image Token ? Cette chaîne est la clé du site.

Impossible de trouver data-sitekey, que puis-je faire?

Nous pouvons trouver le data-sitekey inspectant l'élément ou consulter le code source de la page et rechercher le nom.
Mais il y a certains cas lorsque ce site de données n'est pas aussi évident, dans ce cas, essayez de rechercher des mots similaires ou des chaînes qui commencent par 6L, il n'y a pas de méthode spécifique pour trouver la clé de site, dans le cas de cryptique / dur- pour obtenir le site de données, nous devons utiliser nos compétences pour les obtenir.

Comment utiliser des jetons pour résoudre un recaptcha?

Il existe trois façons dont le jeton peut être utilisé:

Le premier consiste à effectuer une demande de poste à l'URL dans l'attribut action du formulaire avec le jeton défini comme la valeur du champ de texte dont l'ID est g-recaptcha-response. Les autres champs peuvent être remplis selon les souhaits. C'est la méthode recommandée pour consommer le jeton, étant donné qu'elle ne nécessite pas d'émulation de navigateur ou de manipulation DOM.

La deuxième façon est de manipuler le DOM. Si vous développez un script pour résoudre les recaptchas, vérifiez si le langage de programmation ou le framework que vous utilisez dispose d'une bibliothèque pour manipuler le DOM ou exécuter des instructions JavaScript. Les étapes suivantes doivent être effectuées pour utiliser avec succès le jeton:

1. Mettez le jeton comme le HTML intérieur de l'élément avec ID "g-recaptcha-response".
   • Pour le faire avec JavaScript, exécutez: document.getElementById(`g-recaptcha-response`).innerHTML = TOKEN; où TOKEN est la chaîne renvoyée dansla clé text de la réponse de l`API. Placez des guillemets doubles (") avant et après le jeton si la chaîne retournée ne les a pas déjà.
2. Soumettez le formulaire ou remplissez l'action qui nécessite le résolution du Recaptcha.
   • Pour y parvenir avec JavaScript, exécutez: document.getElementById(`FORM_ID`).submit(); où FORM_ID est l`ID du formulaire qui souhaite être soumis.
   • Il ne suffit parfois pas de soumettre le formulaire pour résoudre le recaptcha, dans ces cas, nous devons copier le jeton de résultat de l'API dans l'élément G-RecaptCha-Response, en prenant soin de ne faire que le jeton exact et éviter d'utiliser des espaces et d'autres des caractères tels que des citations ou des citations doubles. Après avoir copie le jeton de résultat dans l'élément, nous avons besoin pour activer l'événement widget vers le captcha être marqué comme résolu.
   
   • Chaque site a un moyen unique de mettre en œuvre le recaptcha, il est recommandé de faire le processus pour un nouveau site manuellement avant d'essayer de l'automatiser, après que nous sommes sûrs que toutes les étapes pour résoudre le recaptcha, nous pouvons utiliser nos outils pour automatiser le processus. Nous prenons en considération que parfois le formulaire de soumission active le recaptcha, parfois nous n'avons pas de formulaire de soumission ou dans d'autres cas est le rappel du captcha qui active l'événement pour accéder aux ressources.

La dernière méthode d`utilisation du jeton consiste à soumettre manuellement le formulaire. Tout d`abord, suivez les étapes 1 et 2 du guide sur la façon de trouver la clé de site spécifiée dans Qu`est-ce qu`une clé de site reCAPTCHA?. Ensuite, copiez l`instruction JavaScript de l`étape 1 décrite ci-dessus, collez-la dans la console du développeur, appuyez sur Entrée et soumettezmanuellement le formulaire.

Remarque: Les méthodes 2 et 3 ne doivent être utilisées qu'à des fins de test car elles sont beaucoup plus lentes et plus intensives en ressources que la première.

Quel est le rappel Recaptcha?

Certains sites peuvent configurer RecaptCha pour donner un rappel sur la validation réussie et éviter l'utilisation du formulaire Soumettre, en utilisant l'attribut de calcul de données sur la balise G-RecaptCha ou via le paramètre `Callback` si vous utilisez un rendu explicite.

La fonction de rappel est souvent définie dans le paramètre de calcul de données de RecaptCha, par exemple:

        data-callback="myFunction";
      

Ou dans certains cas, il est défini comme le paramètre de rappel de la fonction grecaptcha.render, par exemple:

        grecaptcha.render('example', {
          'sitekey' : 'site-key',
          'callback' : myFunction
        });
      

Enfin, tout ce que nous avons à faire est d'appeler cette fonction:

        myFunction();
      

J'utilise le jeton que je reçois de l'API Pourquoi le recaptcha ne résout pas?

Tous les sites implémentent le reCAPTCHA à leur manière, cela signifie que nous devons analyser chaque implémentation du reCAPTCHA sur un site avant d`essayer d`utiliser le jeton de résultat. Une fois que nous sommes sûrs de la façon dont ce site particulier fonctionne, pour ce faire, nous résolvons le défi reCAPTCHA comme un utilisateur normal et obtenons une compréhension de l`implémentation. Ensuite, nous pouvons commencer à essayer d`utiliser manuellement le jeton de résultat à partir de l`API et une fois que nous sommes sûrs du processus, alors nous pouvons automatiser cela. Pour être sûr du fonctionnement du reCAPTCHA, vous pouvez consulter la documentation reCAPTCHA v2. Soyez prudent avec HTML.

Comment vérifier que mon proxy est utilisé pour résoudre un captcha?

Allez à soumissions précédentes Après avoir téléchargé un captcha et vérifié les champs "proxy" et "fournis par procuration" du captcha téléchargé. Si votre proxy a été utilisé pour résoudre le captcha, la valeur du champ "proxy" sera l'adresse IP de votre proxy et le "statut de proxy fourni sera" bon ". S'il n'a pas été utilisé, "Proxy" aura "DBC Proxy" comme valeur (ce qui signifie que CAPTCHA a été résolu en utilisant l'une de nos proxys) et "Fourni statut de proxy" Le champ sera "mauvais ou non fourni". Exemple de capture d'écran:

Exemples de code d'utilisation pour l'API d'image de jeton:

1) Envoyez votre charge utile:

Veuillez noter que nous utilisons l'API de type="4" pour l'image de jeton.

    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) Tirer le captcha: prenez le CAPTCHA_ID donné et faites une demande comme ceci:

curl -H "Accept: application/json" http://api.dbcapi.me/api/captcha/CAPTCHA_ID

Le résultat est une corde JSON où le "texte" du champ comprend la solution respective:

'{"status": 0, "captcha": 2911096,
        "is_correct": true, "text": "textToken"}'

Utilisation de l'API de l'image de jetons avec les clients de l'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);
        * });
        */
    }

});