Tools for Automation: Why Token-Based CAPTCHA Solving Wins Over Clicks

I often come across various tools that make life easier in different areas of work. But today, I’m not talking about mainstream services like GSA or Ahrefs. Instead, let’s discuss heavyweights like Zennoposter and BAS.

For those unfamiliar, these platforms are essentially complex, multi-layered frameworks. Think of them as “lite neural networks” where you can build bots and scripts to automate almost anything without human intervention. Interestingly, tools like these existed long before AI and automation became buzzwords.

Now, let’s get to the point. While diving into BAS, I noticed something intriguing: many developers writing scripts for this platform tend to idealize click-based CAPTCHA solving.

To clarify, I’m talking about visual or image CAPTCHAs — the ones where you pick images or click icons in a specific order. Examples include reCAPTCHA V2, hCaptcha, GeeTest CAPTCHA, and Rotate CAPTCHA.

There are two main ways to solve these CAPTCHAs: tokens and clicks.
If you want a deeper dive into CAPTCHA-solving methods, I highly recommend this article: "CAPTCHA Recognition Simplified: Understanding the Complex Process."

That said, many BAS developers see click-based solving as simpler to implement (spoiler: it’s not). While this method might face fewer restrictions from CAPTCHA services, my experience shows that token-based solving is both faster and more efficient.

The Experiment: Comparing Tokens and Clicks

Scenario: Solve a reCAPTCHA V2 on Google’s demo page.
Goal: Measure and compare the speed of solving CAPTCHAs using both methods.

To test this, I chose two GitHub extensions for Puppeteer:

1. Token-based solving: 2captcha-solver-in-puppeteer.
2. Click-based solving: puppeteer-recaptcha-solver-using-clicks.

While the first extension supports both methods, I included the second one for better visualization since its click-based results were inconsistent during initial testing.

Preparing the Tools

Here’s a breakdown of how I configured the extensions to get started.

Setting Up Token-Based Solving

Both extensions are pre-configured to work with 2Captcha’s demo page. However, I decided to use Google’s reCAPTCHA V2 demo for a more objective test, as it’s slightly more challenging and reduces potential bias.

Here’s what I updated:

1.**config.js**

• File location: \2captcha-solver\common.
• Ensure the CAPTCHA type is set to token (line 11).
• Add your API key (line 4).

1. **manifest.js**

• File location: one level above config.js.
• Remove the following block of code:

"options_ui": {
    "page": "options/options.html",
    "open_in_tab": true
},

**index.js**

• Update the default URL (from 2Captcha’s demo page) to Google’s reCAPTCHA demo.
• Adjust the submit button selector to match Google’s page:

await page.click('#recaptcha-demo-submit');

These tweaks ensure the solver can interact with the required elements on Google’s demo page.

Setting Up Click-Based Solving (Using the Same Extension)

For click-based solving, the setup was simpler:

• Switch the CAPTCHA type to click in config.js.

However, I ran into an issue where the solver couldn’t locate the submit button. To work around this, I commented out a problematic code block and manually clicked the button during tests. While not ideal, this setup was enough for demonstration purposes.

Here’s the commented-out code:

// await page.waitForSelector('.captcha-solver');
// await page.click('.captcha-solver');
// await page.waitForSelector(`.captcha-solver[data-state="solved"]`, {timeout: 150000});
// await page.click('#recaptcha-demo-submit');

Testing the Second Extension

The second extension (puppeteer-recaptcha-solver-using-clicks) required more adjustments:

1. Add your API key.
2. Update the URL to Google’s demo page.
3. Adjust selectors to match Google’s structure (they differ from 2Captcha’s demo page).

While this extension worked after some effort, it was less seamless than the first one.

Results: Tokens vs. Clicks

Test Conditions:

• Standard home PC setup using a non-proxy IP address.
• Each method tested independently.

Speed Comparison

• Token Method: Solved in 18 seconds.
• Click Method (Extension 1): Took 1 minute 10 seconds.
• Click Method (Extension 2): A painful 4 minutes.

What’s clear? Tokens consistently outperform clicks in terms of speed and reliability.

Key Observations

1. IP Reputation Impacts Results

CAPTCHA complexity and solving speed depend heavily on your IP’s reputation. Spammy IPs often face more challenging CAPTCHAs. High-quality proxies can help, though they come with added costs.

2.Clicks Are Less Reliable

Both extensions struggled with click-based solving. Even when the service provided valid responses, the CAPTCHA often requested retries. Token-based solving, by contrast, was more straightforward and error-free.

Conclusion: Tokens for the Win

Based on my results, token-based solving is the clear winner — faster, more reliable, and less prone to errors. While click-based methods have their niche (e.g., grid-based CAPTCHAs), they’re generally slower and less practical for large-scale automation.

For now, tokens are my go-to. Next time, I’ll explore how Selenium handles these methods. Stay tuned!