DEV Community: 2captcha

How to Solve and Overcome reCAPTCHA Automatically with Puppeteer and Auto Captcha Integration

2captcha — Mon, 18 Nov 2024 13:28:59 +0000

Automating reCAPTCHA Bypass Using Puppeteer

This comprehensive guide walks you through the process of bypassing reCAPTCHA challenges using Puppeteer and an auto captcha-solving technique.

You can read original article here - How to automatically solve and bypass reCAPTCHA using Puppeteer and Auto Captcha Filler

Discover how to programmatically solve Google reCAPTCHA using Puppeteer alongside an automated captcha resolution system in this step-by-step tutorial.

Automating reCAPTCHA Challenges Using Puppeteer and Captcha Solvers

Here, we demonstrate the process of bypassing image-based reCAPTCHA tasks (3x3 or 4x4 grids) by leveraging Puppeteer in combination with 2Captcha, a third-party captcha-solving service.

The script automates interaction with reCAPTCHA by retrieving the challenge, sending it for API-based resolution, and simulating user actions like clicking the correct answers provided by the solver.

This fully automated approach simplifies CAPTCHA bypassing in web automation scenarios.

Setting Up the Script

Clone the Repository

git clone git@github.com/2captcha/puppeteer-recaptcha-solver-using-clicks.git  
cd puppeteer-recaptcha-solver-using-clicks

Install Dependencies

npm install

Run the Script

npm run start

Configuration Instructions

To enable the script, configure your 2Captcha API key by setting the APIKEY environment variable:

export APIKEY=your_api_key

How the Script Operates

CAPTCHA Extraction: The challenge image and parameters are programmatically retrieved.
Data Submission: The image data is sent to the solver API, which resolves the CAPTCHA by identifying grid cells containing target objects.
Interaction Simulation: Using the provided solution, Puppeteer clicks the required cells in the reCAPTCHA widget and submits the challenge.

Example of Extraction Output:

{  
  "rows": 3,  
  "columns": 3,  
  "type": "GridTask",  
  "comment": "Select all images with crosswalks. Click verify when none are left.",  
  "body": "XXXXXXXX"  
}

Example of Solver Output:

{  
  "status": 1,  
  "data": "click:3/6/8",  
  "id": "XXXXXXXX"  
}

Here, click:3/6/8 directs you to click the 3rd, 6th, and 8th grid squares. Grid numbering begins at the top-left corner, progressing row by row.

Key Features

Token-Free Approach: Avoids managing tokens manually, instead relying on grid interactions to validate responses.
Simplified Process: Leverages reCAPTCHA’s built-in verification to simplify logic and reduce complexity.

Advantages:

Reduces reliance on token management.
Mimics user behavior, enhancing compatibility with reCAPTCHA systems.

Challenges:

Requires browser automation, which adds code complexity.
CAPTCHA-solving cost and speed may vary with task difficulty.

Error Management

Unsolvable CAPTCHAs: If a CAPTCHA is deemed unsolvable, retry or escalate the task.
Rate Limits: Excessive requests may temporarily block your IP; mitigate this by switching IPs or waiting before retrying.

For Python users, check out our repository for similar automation examples using Selenium and Python: [reCAPTCHA Solver with 2Captcha and Selenium].

Automating reCAPTCHA Bypass with Selenium and Captcha Solvers

2captcha — Mon, 18 Nov 2024 12:25:51 +0000

Efficiently Solving reCAPTCHA Challenges Using Selenium

This guide provides a detailed walkthrough for bypassing Google reCAPTCHA challenges using Selenium and automated captcha-solving solutions.

You can read original article here - How to automatically solve and bypass reCAPTCHA using Selenium and Auto Captcha Filler

Learn the steps to seamlessly automate solving image-based reCAPTCHA tasks through Selenium and third-party captcha-solving APIs in this tutorial.

Automating CAPTCHA Handling with Selenium and Grid-Based Methods

This article outlines the process for bypassing image-based reCAPTCHA challenges (e.g., 3x3 or 4x4 grids) by combining Selenium with the 2Captcha service.

Here’s how the script operates:

Challenge Detection: Identifies the reCAPTCHA widget on the target webpage.
Data Collection: Retrieves necessary CAPTCHA parameters and images.
External Solving: Sends the extracted data to the captcha solver API for processing and receives the solution.
Interaction Simulation: Simulates user behavior by clicking or submitting the solution to reCAPTCHA, bypassing detection systems.

This method fully automates the bypassing process, streamlining CAPTCHA handling for web automation tasks.

Setting Up the Environment

Clone the Repository

git clone git@github.com/2captcha/selenium-recaptcha-solver-using-grid.git  
cd selenium-recaptcha-solver-using-grid

Install Dependencies

pip install -r requirements.txt

Run the Script

python main.py

Configuration Guide

To activate the script, set your 2Captcha API key as an environment variable:

export APIKEY=your_api_key

How the Solution Works

Data Extraction: The script retrieves the CAPTCHA challenge and relevant parameters programmatically.
API Communication: Sends the image data to a third-party solver using the grid method to identify target areas.
User Interaction Simulation: Selenium clicks the appropriate areas based on the solver’s response and verifies the solution.

Example of CAPTCHA Extraction Output:

{  
  "rows": 3,  
  "columns": 3,  
  "type": "GridTask",  
  "comment": "Select all images with crosswalks. Click verify once there are none left.",  
  "body": "XXXXXXXX"  
}

Example of Solver Response:

{  
  "status": 1,  
  "data": "click:3/6/8",  
  "id": "XXXXXXXX"  
}

Here, click:3/6/8 specifies the grid cells to click, starting from the top-left and proceeding row by row.

Key Features

Selenium WebDriver Integration: Handles browser-based CAPTCHA interactions.
2Captcha API Usage: Solves complex image challenges efficiently.
Support for Grid Variants: Works with both 3x3 and 4x4 reCAPTCHA grids.
Error Handling Mechanisms: Manages CAPTCHA failures and retries.

Advantages:

Bypasses direct token management by leveraging visual interactions.
Simplifies CAPTCHA handling with built-in reCAPTCHA validation.

Challenges:

Relies on Selenium for browser automation, which requires additional resources.
The cost and solving time depend on CAPTCHA complexity.

Error Handling

Unsolvable CAPTCHAs: Some challenges may be too complex for solvers. Add retry or escalation mechanisms to handle these scenarios.
Rate Limiting: ReCAPTCHA may block repeated requests from the same IP. Mitigate this by switching IPs or pausing before retrying.

For those working with JavaScript, a similar repository demonstrates how to automate CAPTCHA handling with Puppeteer: [reCAPTCHA Solver Using 2Captcha and Puppeteer].

Bypassing CAPTCHA with Python: What’s the Challenge? Certain Nuances Exist

2captcha — Tue, 29 Oct 2024 09:52:26 +0000

I am not a developer by profession, but I work closely within those circles — let’s call it the Python-adjacent crowd. I know some developers, and even more so, colleagues who specialize in the field.

As it happens, I needed to set up a CAPTCHA-solving mechanism using Python for an important project — an Amazon parser. I tried countless approaches, burned through tons of GPT prompts, but the infamous Amazon CAPTCHA was unyielding. Eventually, through a bit of crowd-sourcing (well, I asked for help, and a colleague provided the solution), a Python script for CAPTCHA bypass was created. Sharing it publicly is driven purely by benevolent motives with a bit of personal interest. I need advice on optimizing this script’s performance, as even after extensive testing, it remains unstable. We’ve tried multiple approaches, broken several libraries, and still haven’t achieved a reliable script.

Let’s go over the steps:

General Overview of the Python CAPTCHA Bypass Script

The CAPTCHA bypass script in Python works as follows:

Imports the necessary libraries.
Configures proxy settings.
Opens Amazon’s registration page.
Solves the first CAPTCHA (skips if none appears).
Completes the registration form.
Solves the second CAPTCHA using a coordinate-based method.
Verifies the CAPTCHA solution.
Closes the browser.

Now, let’s take a closer look at each step.

Required Python Libraries for CAPTCHA Solving

The script relies on several libraries:

os, base64, BytesIO - standard Python libraries used for file system operations, encoding images in base64, and working with byte streams (these libraries support CAPTCHA-solving in image format).
seleniumbase.Driver, selenium.webdriver.common.by.By, selenium.webdriver.common.action_chains.ActionChains - These libraries enable Selenium-driven browser control, allowing element searches on web pages and complex actions (like clicking specific coordinates). Essentially, this set is focused on coordinate-based CAPTCHA solving, though all CAPTCHA interactions here depend on Selenium, making it a key library set.
TwoCaptcha: This library connects to the 2Captcha service for automated CAPTCHA recognition (naturally, Python CAPTCHA solving is implemented through an external service, in our case, 2Captcha).

Proxy Configuration for Script Functionality

Initially, the script was designed to retrieve proxies from a file. But as I’m somewhat lazy (What? Create a proxy file, figure out the right format, and prepare the proxies? You’ve got to be kidding!), I added the option to use proxies directly from the code.

The script checks first if a proxy file exists, and if it doesn’t, it loads the proxy from the code. If neither contains proxy data, the script simply gives up and shuts down (just like some people — “I’m a simple person, if no tasks are assigned, I just scroll through videos”).

In modern web scraping, bypassing CAPTCHA without proxies is almost unheard of (especially for high-volume scraping), regardless of whether you’re using Python or another language.

Opening the Amazon Registration Page

Next, the script opens Amazon’s registration page (handled by the function driver.uc_open_with_reconnect). After all, the goal here is to complete the registration on the site, not just solve CAPTCHA (though it currently isn’t doing much beyond that, to be honest).

Solving the First CAPTCHA in Python

Finally, we arrive at the core function (or rather, part of it) — CAPTCHA bypass or skip if no CAPTCHA appears. We’re talking about Amazon’s simple text CAPTCHA, which sometimes shows up, sometimes doesn’t (Amazon seems to have its off days).

Here’s how it works: the script uses Selenium to locate the CAPTCHA image on the page, takes a screenshot, converts it to base64, and sends the encoded data to 2Captcha. Once the response is received, the text is entered into a designated field, and the “Continue” button is clicked.

If no CAPTCHA is present, this step is skipped, and the script proceeds to the next section.

Filling Out the Registration Form

As you remember, the script opened the registration page before attempting to solve the CAPTCHA. Now, it returns to that page to fill out the registration form.

The registration form data is loaded directly from the code. This approach was chosen to simplify the CAPTCHA recognition module, though ideally, this could be improved by adding a solution that pulls form data from a file, filling out multiple forms automatically.

Python CAPTCHA Bypass via Coordinate-Based Method

Throughout the testing phase, we encountered no issues with the first CAPTCHA (Amazon seemed to be in a good mood and didn’t issue the text CAPTCHA). However, the second CAPTCHA raised questions, both for the script and the community.

Here’s the breakdown:

The second CAPTCHA is more complex and requires clicking on specific coordinates to solve it. The script’s workflow is as follows: it takes a screenshot, sends it to the service to get coordinates, and then uses ActionChains to move the cursor to those coordinates, switches to the frame, and clicks the confirm button.

But here comes the snag. Occasionally, either during recognition or verification, the process stalls. The CAPTCHA might not resolve, or the allotted time for solving expires before the correct result is returned. While most cases proceed smoothly, this rare exception is puzzling and persistent.

Below is the script itself. It may be useful to someone, or perhaps someone in the comments can suggest improvements to address this issue?

Or maybe it can’t be fixed, because, after all — “This is Amazon”...

import os
import base64
from io import BytesIO
from seleniumbase import Driver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.action_chains import ActionChains
from twocaptcha import TwoCaptcha  # pip3 install 2captcha-python

# Manual proxy input
manual_proxy = "http://login:password@ip:port"  # Replace with your proxy

# Function to read proxy from file
def get_proxy_from_file(file_path):
    if os.path.exists(file_path):
        with open(file_path, 'r') as file:
            proxy = file.read().strip()
            return proxy
    return None

# Attempt to connect via proxy from file or use manual input
proxy_file_path = "proxy.txt"  # Proxy file name
proxy = get_proxy_from_file(proxy_file_path) or manual_proxy

my_key = "2Captcha API Key"
solver = TwoCaptcha(my_key, defaultTimeout=70)
agent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36"

# Initialize driver with proxy
driver = Driver(uc=True, headless=False, proxy=proxy, agent=agent)  # headless=True for invisible mode

try:
    url = "https://www.amazon.com/ap/register?openid.pape.max_auth_age=0&openid.identity=http%3A%2F%2Fspecs.openid.net%2Fauth%2F2.0%2Fidentifier_select&pageId=usflex&ignoreAuthState=1&openid.assoc_handle=usflex&openid.mode=checkid_setup&openid.ns.pape=http%3A%2F%2Fspecs.openid.net%2Fextensions%2Fpape%2F1.0&prepopulatedLoginId=&failedSignInCount=0&openid.claimed_id=http%3A%2F%2Fspecs.openid.net%2Fauth%2F2.0%2Fidentifier_select&disableLoginPrepopulate=1&switch_account=signin&openid.ns=http%3A%2F%2Fspecs.openid.net%2Fauth%2F2.0"
    driver.uc_open_with_reconnect(url, 5)

    # Solving first CAPTCHA
    try:
        my_img = driver.find_element("body > div > div.a-row.a-spacing-double-large > div.a-section > div > div > form > div.a-row.a-spacing-large > div > div > div.a-row.a-text-center > img")
        print("SOLVE FIRST CAPTCHA...")
        screenshot = my_img.screenshot_as_png
        screenshot_bytes = BytesIO(screenshot)
        base64_screenshot = base64.b64encode(screenshot_bytes.getvalue()).decode('utf-8')
        result = solver.normal(base64_screenshot)
        print('result: ' + str(result))  # Send request to 2Captcha
        res = result['code']
        driver.find_element(By.ID, "captchacharacters").send_keys(f"{res}")
        driver.find_element(By.CLASS_NAME, "a-button-inner").click()
    except:
        pass

    # Waiting and form filling
    driver.sleep(1)
    print("Fill out the form")
    driver.find_element(By.ID, "ap_customer_name").send_keys("Alex0053")  # Fill form
    driver.find_element(By.ID, "ap_email").send_keys("some_post43120@gmail.com")
    driver.find_element(By.ID, "ap_password").send_keys("password40000A#")
    driver.find_element(By.ID, "ap_password_check").send_keys("password40000A#")
    driver.find_element(By.ID, "continue").click()
    driver.sleep(10)

    # Second CAPTCHA - coordinate-based
    while True:
        try:
            cap_img = driver.find_element(By.ID, "cvf-aamation-challenge-iframe")  # Frame element
            print("SOLVE SECOND-COORD CAPTCHA...")
            screenshot = cap_img.screenshot_as_png
            screenshot_bytes = BytesIO(screenshot)
            base64_screenshot = base64.b64encode(screenshot_bytes.getvalue()).decode('utf-8')
            element_position = cap_img.location
            result = solver.coordinates(base64_screenshot, lang='en', min_clicks=1, max_clicks=1)
            x = str(result['code']).split(":")[1].split(",")[0].replace("x=", "")
            y = str(result['code']).split(":")[1].split(",")[1].replace("y=", "")
            print('result: ' + str(result))
            x_coord = element_position["x"] + int(x)
            y_coord = element_position["y"] + int(y)
            actions = ActionChains(driver)
            actions.move_by_offset(x_coord, y_coord).click().perform()
            driver.sleep(2)
            actions.reset_actions()
            driver.switch_to_frame(cap_img)
            driver.find_element(By.ID, "amzn-btn-verify-internal").click()
            driver.switch_to.default_content()
            driver.sleep(7)
        except Exception as e:
            print(e)
        try:
            driver.find_element('form[id="verification-code-form"]')
            print("CAPTCHA PASSED!!!")
            break
        except:
            pass

    driver.sleep(3)
    # Last block, if needed

except Exception as e:
    print(e)
finally:
    driver.close()
    driver.quit()

Python CAPTCHA Bypass – Missing Part of the Code

Amazon also has a third type of CAPTCHA, FunCaptcha, which I couldn’t crack in this context. So, I just removed it from this code, just in case. I haven’t encountered FunCaptcha throughout testing (but from the tales of wiser folk, I know it exists somewhere in Amazon’s depths). There’s a legend about a specially trained man, we’ll call him the Overseer, who manually changes CAPTCHA conditions or the page design.

No one has ever seen this Overseer, but in the evenings, when IT folks gather around a fire, they use this tale to scare the juniors.

So, the script doesn’t solve FunCaptcha, but I’m open to suggestions on how to enable it to do so.

Conclusion

The script works, CAPTCHA is bypassed, but occasional stalls remain – it would be helpful if you could point out any improvements (preferably without harsh critique).

The script doesn’t handle FunCaptcha, though at first glance, we don’t really need it, but if it is required — I’m also open to community input.

How to bypass reCAPTCHA V2/V3 using code and another way

2captcha — Mon, 16 Sep 2024 09:03:50 +0000

How to bypass reCAPTCHA v2/v3: Automatically solve and pass Google reCAPTCHA using Python and Selenium, Puppeteer, Javascript, PHP

Bypassing reCAPTCHA

No matter how many times people wrote that the captcha has outlived itself long time ago and no longer works as effectively as its developers would have liked initially, however, the owners of Internet resources continue to protect their projects with captchas. But what is the most popular captcha of our time?

CAPTCHA is annoying, but 2captcha service helps to bypass it. We will consider part of the reCAPTCHA solver service

It is recaptcha. Recaptcha V2, V3, etc., that was created by Google back in 2007. It has been many years since the first recaptcha appeared, but it continues to keep the garland, periodically losing ground to competitors and then winning it back. But recaptcha has never taken the 2nd place in popularity, despite all its imperfections in front of neural networks.

There was a huge number of attempts to create a "recaptcha killer", some were less successful, some only looked like a threat to recaptcha, but in fact turned out to be nothing. Yet the fact remains that the desire of competitors to do something better and more reliable than recaptcha demonstrates its popularity.

Types of reCAPTCHA

ReCAPTCHA can be classified into three versions

reCAPTCHA V1
reCAPTCHA V2
reCAPTCHA V3

Each of them is an improved version of the previous reCAPTCHA . Let's figure it out in more detail:

How to solve reCAPTCHA V1? Easy!

The very first version of the CAPTCHA reCAPTCHA V1 consisted of excerpts of text from scanned books, it was also called a text CAPTCHA. It was a fairly simple CAPTCHA that was very intrusive and annoying to users.

The user was asked to enter text in a special window, now something like this can still be found on old resources, but no one uses reCAPTCHA V1 on normal sites anymore.

ReCAPTCHA V1 was the first version introduced in 2007. It used distorted text from scanned books that users had to type in to prove they weren't bots. This system used user input to digitize books, newspapers, and old radio shows.

It was during the period when Google introduced the first version of reCAPTCHA, that auto reCAPTCHA solvers began to appear, that were easily bypassing the text CAPTCHA. At first they were trained on an array and then put into operation, over time such solvers made fewer and fewer mistakes and saved the owner a lot of time and money.

All kinds of auto reCAPTCHA solver chrome extensions that work with the CAPTCHA recognition service, cope well with the text CAPTCHA. Modern alternatives, like reCAPTCHA solver github, offer refined solutions to these challenges, continuing the evolution of CAPTCHA solvers.

reCAPTCHA v2 – how to bypass images? Where is text?

After realizing that text CAPTCHAs no longer work, a new V2 CAPTCHA was created. It was designed to soothe the irritation of users from the annoyance caused by the first version, increase security when protecting projects and, in general, improve the user experience.

The second version of the reCAPTCHA is an empty field. When you click on it, a check mark appears and the CAPTCHA is passed. Or it might be a pop-up window with traffic lights that you need to find. Traffic lights, of course, are a metaphor, instead of traffic lights, you had to look for various objects. I'm sure you all understand what I'm talking about.

Checkbox ("I am not a robot"): The simplest type of verification, where the user just needs to click on the checkbox. The system analyzes the user's behavior to determine whether it is a human or a bot.

Image tasks: If the system is in doubt, it prompts users to select certain objects in the images (for example, "Select all images with traffic lights").

And there was a lack of methods for bypassing reCAPTCHA V2, such as reCAPTCHA v2 solver, reCAPTCHA v2 invisible solver, and even reCAPTCHA v2 callback solver. Many auto-resolvers stopped working normally, the market began to rebuild, and continues to develop even now, as more and more new parameters that are taken into account when solving reCAPTCHA appear, including solutions like bypass reCAPTCHA v2 and bypass reCAPTCHA v2 invisible.

Despite the novelty, the second version also greatly irritated ordinary people, and that negativity did not go away. The system was imperfect, which prompted Google to go ahead and create new products, as developers struggled with challenges like google reCAPTCHA v2 bypass and sought automated solutions.

Google reCAPTCHA v3 – how to bypass something invisible?

The decision not to annoy the users was pursued by Google at all stages of creating reCAPTCHA, but how to achieve that? By hiding the reCAPTCHA. So the third version became invisible. It works in the background, continuously monitoring user actions on the site and assigning them a risk score (from 0.1 to 1.0) based on their behavior. This evolution led to the need for solutions capable of interacting with this more complex system, such as various reCAPTCHA v3 solvers and techniques for bypassing reCAPTCHA V3.

Websites can set thresholds for risk assessments, determining the level of interaction or verification depending on the perceived risk. If the owner wants to maximize the user experience, they set a lower score and vice versa. As more sophisticated methods were developed, some began to explore options like bypassing reCAPTCHA V3 using different programming languages or tools. Thus, Google has given owners a choice between user experience and protection, and it is not so difficult to find a balance in this case.

Python and reCAPTCHA, what are the top reCAPTCHA solvers in Python?

The most popular programming language is definitely Python, the code for this programming language is searched in 5 out of 10 cases when people google "How to bypass reCAPTCHA" on the Internet (not taking into account queries that contain the word Python, such as "how to bypass reCAPTCHA in Python", "Python reCAPTCHA solver", or "Python reCAPTCHA bypass", and so on).

The easiest way to implement all this will be with using modules that just need to be connected in an executable file. After studying the Internet, I have identified the following popular modules with which you can recognize reCAPTCHA (by the way, with all these modules you can recognize other types of CAPTCHA):

Python module for 2Captcha to avoid reCAPTCHA (CAPTCHA solver API)

The official module from the captcha recognition service 2Captcha (2captcha-python) is designed for easy integration with their API. The module has advanced functionality and supports proxy configuration. The module is maintained and regularly updated, and can be used for parsing web resources and automation. This module is often used in conjunction with Python reCAPTCHA solver approaches, making it a powerful tool for those looking to bypass reCAPTCHA v2 Python.

The service is ideal for users that focus on reliability in CAPTCHA recognition, as well as those who need official support from the 2Captcha service. Python bypass reCAPTCHA techniques are effectively implemented using this module, especially for tasks requiring stability and support.

The module supports asynchronous operations.

Google reCAPTCHA solver module for Python

A module 2captcha-solver for solving reCAPTCHA and some other popular CAPTCHAs (reCAPTCHA (v2, v3), FunCaptcha, and hCaptcha). Its main difference from the previous module is that it is more narrowly focused (supports fewer CAPTCHAs) and can respond less flexibly to updates from the reCAPTCHA, compared with the previous official module. However, it remains a valuable option for those seeking a Python reCAPTCHA v2 solver or even a Python reCAPTCHA v3 solver.

2captcha-solver supports proxy configuration and is especially useful for tasks requiring high performance, thanks to its support for asynchronous operations, which allows you to simultaneously solve multiple reCAPTCHAs.

Module written by Python - reCAPTCHA solver

A multifunctional module captchatools, the main focus of which is on supporting several CAPTCHA recognition services. The functionality of the module is approximately similar to the previous two, it supports proxy configuration and asynchronous operations. For those who need to implement Python reCAPTCHA bypass or Python google reCAPTCHA solver strategies, captchatools offers flexible options.

Based on the fact that the module allows you to integrate CAPTCHA recognition through several services, it has a unique function – brute force search for services. That is, you can use one service as the main one, and others as backup, and when, for example, you run out of funds on the main service, or if the main service could not cope with the task, the CAPTCHA will go to the backup one and will be solved. This way your script will be more automated and will not depend on the stability of one particular service.

Module for bypass reCAPTCHA by Python (for Selenium)

It is a narrowly focused module twocaptcha-extension-python that is used for easy integration with Selenium and Playwright, and supports all types of reCAPTCHA. This module is particularly useful for those who need to implement Python bypass reCAPTCHA via selenium or other similar tasks.

The module can be used without the need to install additional extensions and only the API key is required for the start. Its integration capabilities make it an excellent choice for developers working on Python solve reCAPTCHA projects.

Its main difference from the previous modules is that twocaptcha-extension-python will be difficult to use for automation issues where Selenium or Playwright are not used, since it is used exclusively for the listed services.

Module to bypass reCAPTCHA V2/V3 by Python

A module Captcha-Tools that resembles captchatools in functionality, and it can be called an analog of the specified service. That is, you can use one of them by choice.

All the characteristics are the same: support for multiple services, brute force search for services in the process of CAPTCHA recognition, asynchronous operations, proxy configuration. It's all here, too. Only the developer is different.

Well, and an assumption from me, most likely both of these services will react a little slower than the official modules to changes that occur in CAPTCHA recognition services and which are made by CAPTCHA developers.

I would also like to note that all of these services (not just Twocaptcha-extension-python) can be used together with Selenium and Playwright, the only difference will be in connection and synchronization.

How to bypass reCAPTCHA using Selenium

Selenium is a powerful tool for browser automation, often used to bypass reCAPTCHA in web application testing and automation processes. This framework allows you to simulate user actions such as clicks, text input, and page navigation, making it ideal for handling various types of reCAPTCHA, including reCAPTCHA V3

There are specialized modules designed to work with Selenium that simplify the process of bypassing reCAPTCHA. These modules automate the task of bypassing reCAPTCHA, enabling efficient handling of tasks like identification and circumvention of reCAPTCHA, processing complex scenarios, and interacting with dynamic content on web pages. Using Selenium in combination with these modules significantly enhances the efficiency of automated testing and optimizes processes related to bypassing reCAPTCHA.

How to bypass reCAPTCHA using Python (example of a code)

If you do not trust any third-party modules, I have prepared the most universal code that can be inserted into your Python script with minor modifications and solve the reCAPTCHA automatically. Here is the code itself:

import requests
    import time

    API_KEY = 'Your_API_2Captcha_key'

    def solve_recaptcha_v2(site_key, url):
        payload = {
            'key': API_KEY,
            'method': 'userrecaptcha',
            'googlekey': site_key,
            'pageurl': url,
            'json': 1
        }

        response = requests.post('https://2captcha.com/in.php', data=payload)
        result = response.json()

        if result['status'] != 1:
            raise Exception(f"Error when sending captcha: {result['request']}")

        captcha_id = result['request']

        while True:
            time.sleep(5)
            response = requests.get(f"https://2captcha.com/res.php?key={API_KEY}&action=get&id={captcha_id}&json=1")
            result = response.json()

            if result['status'] == 1:
                print("Captcha solved successfully.")
                return result['request']
            elif result['request'] == 'CAPCHA_NOT_READY':
                print("The captcha has not been solved yet, waiting...")
                continue
            else:
                raise Exception(f"Error while solving captcha: {result['request']}")

    def solve_recaptcha_v3(site_key, url, action='verify', min_score=0.3):
        payload = {
            'key': API_KEY,
            'method': 'userrecaptcha',
            'googlekey': site_key,
            'pageurl': url,
            'version': 'v3',
            'action': action,
            'min_score': min_score,
            'json': 1
        }

        response = requests.post('https://2captcha.com/in.php', data=payload)
        result = response.json()

        if result['status'] != 1:
            raise Exception(f"Error when sending captcha: {result['request']}")

        captcha_id = result['request']

        while True:
            time.sleep(5)
            response = requests.get(f"https://2captcha.com/res.php?key={API_KEY}&action=get&id={captcha_id}&json=1")
            result = response.json()

            if result['status'] == 1:
                print("Captcha solved successfully.")
                return result['request']
            elif result['request'] == 'CAPCHA_NOT_READY':
                print("The captcha has not been solved yet, waiting...")
                continue
            else:
                raise Exception(f"Error while solving captcha: {result['request']}")

    # Usage example for reCAPTCHA v2
    site_key_v2 = 'your_site_key_v2'
    url_v2 = 'https://example.com'
    recaptcha_token_v2 = solve_recaptcha_v2(site_key_v2, url_v2)
    print(f"Received token for reCAPTCHA v2: {recaptcha_token_v2}")

    # Usage example for reCAPTCHA v3
    site_key_v3 = 'your_site_key_v3'
    url_v3 = 'https://example.com'
    recaptcha_token_v3 = solve_recaptcha_v3(site_key_v3, url_v3)
    print(f"Received token for reCAPTCHA v3: {recaptcha_token_v3}")

However, before using the provided script, carefully read the recommendations of the service for recognizing a particular type of recaptcha in order to have an idea how this code works.

Also, do not forget to insert your API key in the code and, of course, install the necessary modules.

JavaScript and reCAPTCHA, how to bypass reCAPTCHA in Javascript using modules

The second most popular language for which users are looking to find ways to bypass reCAPTCHA is node js, about 3 out of 10 requests to bypass reCAPTCHA come to this programming language.

As in the case of Python, it is easiest to recognize reCAPTCHA through special modules, especially since CAPTCHA recognition services are interested in simplifying work for their customers and many create and maintain such modules, here is a list of the most popular ones that can help you bypass reCAPTCHA in JavaScript.

Module to bypass reCAPTCHA using Javascript

The official module for node js from the CAPTCHA recognition service 2Captcha (2captcha), supports most of the known types of CAPTCHA, including reCAPTCHA. An important difference between this module and the others is TypeScript support, which makes it convenient for development of various applications.

All basic settings, including asynchronous operations, proxy settings, etc. are present in the module, which makes it a universal module for solving most types of CAPTCHA. Well, and the fact that the module was created by the 2Captcha service allows us to draw a conclusion about its reliability.

Javascript module for 2Captcha to pass reCAPTCHA

It is also the official module for recognizing the main types of CAPTCHA from the 2Captcha service (2captcha-javascript), and it supports all the same settings as the previous module (with the exception of TypeScript support), but it seemed to me that it was created more with an emphasis on ease of integration and a quick start.

It is simpler than the previous one and, like its predecessor, it solves the main task – bypassing reCAPTCHA. So, if you just need your script (program) written in node js to bypass reCAPTCHA, use this module, and if you need deeper integration, take a closer look at the previous module.

Module to bypass Google reCAPTCHA response

The module is tailored for integration with Puppeteer and allows you to solve reCAPTCHA and other popular types of CAPTCHA.

In addition to the fact that this module is tailored for Puppeteer, it provides the opportunity to choose a provider that solves the CAPTCHA, which also allows you to configure a brute force search for services (as described in the section about modules for Python).

It should be noted that the two previous modules can be integrated into Puppeteer, but captcha-solver provides an out-of-the-box solution, that is, you set it up and forget about it, whereas in the case of 2captcha and 2captcha-javascript, manual processing of the results or configuring this processing may be required.

Javascript module to skip reCAPTCHA

A module from third-party developers that supports the reCAPTCHA solution (Multi-captcha-solver-adapter), as well as some other popular types of CAPTCHA. Several CAPTCHA recognition services are integrated in the module, which allows you to configure a brute force search for services (make one the main one, and make the rest backup ones).

The service is an alternative to 2captcha and 2captcha-javascript, but there may be delays in updating, since the module is not supported by official services, but otherwise its functionality is similar to its competitors.

How to bypass reCAPTCHA in Node JS

As in the case of Python, for those who do not like ready-made solutions, below is a script for solving a CAPTCHA using the node js programming language. I remind you to not forget to install the necessary modules for the code to work, including:

axios

You can install it using this command

npm install axios

Here is the code itself:

const axios = require('axios');
    const sleep = require('util').promisify(setTimeout);

    const API_KEY = 'YOUR_API_KEY_2CAPTCHA'; // Replace with your real API key

    // Function for reCAPTCHA v2 solution
    async function solveReCaptchaV2(siteKey, pageUrl) {
        try {
            // Sending a request for the captcha solution
            const sendCaptchaResponse = await axios.post(`http://2captcha.com/in.php`, null, {
                params: {
                    key: API_KEY,
                    method: 'userrecaptcha',
                    googlekey: siteKey,
                    pageurl: pageUrl,
                    json: 1
                }
            });

            if (sendCaptchaResponse.data.status !== 1) {
                throw new Error(`Error when sending captcha: ${sendCaptchaResponse.data.request}`);
            }

            const requestId = sendCaptchaResponse.data.request;
            console.log(`Captcha sent, request ID: ${RequestId}`);

            // Waiting for the captcha solution
           while (true) {
                await sleep(5000); // Waiting 5 seconds before the next request

                const getResultResponse = await axios.get(`http://2captcha.com/res.php`, {
                    params: {
                        key: API_KEY,
                        action: 'get',
                        id: requestId,
                        json: 1
                    }
                });

                if (getResultResponse.data.status === 1) {
                    console.log('Captcha solved successfully.');
                    return getResultResponse.data.request;
                } else if (getResultResponse.data.request === 'CAPCHA_NOT_READY') {
                    console.log('The captcha has not been solved yet, waiting...');
                } else {
                    throw new Error(`Error while solving captcha: ${getResultResponse.data.request}`);
                }
            }
        } catch (error) {
            console.error(`An error occurred: ${error.message}`);
        }
    }

    // Function for reCAPTCHA v3 solution
    async function solveReCaptchaV3(siteKey, pageUrl, action = 'verify', minScore = 0.3) {
        try {
            // Sending a request for the captcha solution
            const sendCaptchaResponse = await axios.post(`http://2captcha.com/in.php`, null, {
                params: {
                    key: API_KEY,
                    method: 'userrecaptcha',
                    googlekey: siteKey,
                    pageurl: pageUrl,
                    version: 'v3',
                    action: action,
                    min_score: minScore,
                    json: 1
                }
            });

            if (sendCaptchaResponse.data.status !== 1) {
                throw new Error(`Error when sending captcha: ${sendCaptchaResponse.data.request}`);
            }

            const requestId = sendCaptchaResponse.data.request;
            console.log(`Captcha sent, request ID: ${RequestId}`);

            // Waiting for the captcha solution
            while (true) {
                await sleep(5000); // Waiting 5 seconds before the next request

                const getResultResponse = await axios.get(`http://2captcha.com/res.php`, {
                    params: {
                        key: API_KEY,
                        action: 'get',
                        id: requestId,
                        json: 1
                    }
                });

                if (getResultResponse.data.status === 1) {
                    console.log('Captcha solved successfully.');
                    return getResultResponse.data.request;
                } else if (getResultResponse.data.request === 'CAPCHA_NOT_READY') {
                    console.log('The captcha has not been solved yet, waiting...');
                } else {
                    throw new Error(`Error while solving captcha: ${getResultResponse.data.request}`);
                }
            }
        } catch (error) {
            console.error(`An error occurred: ${error.message}`);
        }
    }

    // Usage example for reCAPTCHA v2
    (async () => {
        const siteKeyV2 = 'YOUR_SITE_KEY_V2'; // Replace with the real site key
        const pageUrlV2 = 'https://example.com '; // Replace with the real URL of the page

        const tokenV2 = await solveReCaptchaV2(siteKeyV2, pageUrlV2);
        console.log(`Received token for reCAPTCHA v2: ${tokenV2}`);
    })();

    // Usage example for reCAPTCHA v3
    (async () => {
        const siteKeyV3 = 'YOUR_SITE_KEY_V3'; // Replace with the real site key
        const pageUrlV3 = 'https://example.com '; // Replace with the real URL of the page
        const action = 'homepage'; // Replace with the corresponding action
        const MinScore = 0.5; // Set the minimum allowed score

        const tokenV3 = await solveReCaptchaV3(siteKeyV3, pageUrlV3, action, minScore);
        console.log(`Received token for reCAPTCHA v3: ${tokenV3}`);
    })();`

Also, do not forget to insert your API key into the code, instead of

`"'YOUR_API_KEY_2CAPTCHA'"

PHP and reCAPTCHA, how to bypass reCAPTCHA in php using modules

And the third most popular language for which users are looking to find ways to bypass reCAPTCHA is PHP. I suggest to start with modules, as in the first two cases, and to end with the code. So, the most popular modules for solving reCAPTCHA in PHP are the following:

Module wriiten by PHP using reCAPTCHA bypass API

This module (2captcha-php) makes it easy to integrate the 2Captcha API into your PHP CAPTCHA solution code. It supports CAPTCHA types such as reCAPTCHA, FunCaptcha, GeeTest, and others. The module is designed for quick setup and use, including support for text CAPTCHA and reCAPTCHA v3. It also supports various methods for working with images and audio files. For those looking to bypass reCAPTCHA in PHP, this module offers a reliable and straightforward solution.

Module to reCAPTCHA bypass in Chrome

A module that provides a user-friendly interface for integration with various CAPTCHA services, including 2Captcha (php-captcha-solver). It supports various types of CAPTCHA, such as reCAPTCHA and FunCaptcha. This module is focused on ease of use and quick setup. If you're aiming to bypass reCAPTCHA using PHP, this tool is also a solid option.

In fact, if we compare these two modules, the first one is developed by the 2Captcha service, and the second one is made by the developer community, and both solve the same tasks and have approximately the same set of functionality. However, the second module may be less prompt in terms of updates, unlike the official module.

How to recognize reCAPTCHA in PHP

Well, for those who are not used to using ready-made modules, here is the code for integration directly. The code uses standard PHP functions such as file_get_contents and json_decode, here is the code itself:

<?php

    function solveRecaptchaV2($apiKey, $siteKey, $url) {
        $requestUrl = "http://2captcha.com/in.php?key={$apiKey}&method=userrecaptcha&googlekey={$siteKey}&pageurl={$url}&json=1";

        $response = file_get_contents($requestUrl);
        $result = json_decode($response, true);

        if ($result['status'] != 1) {
            throw new Exception("Error when sending captcha: " . $result['request']);
        }

        $captchaId = $result['request'];

        while (true) {
            sleep(5);
            $resultUrl = "http://2captcha.com/res.php?key={$apiKey}&action=get&id={$captchaId}&json=1";
            $response = file_get_contents($resultUrl);
            $result = json_decode($response, true);

            if ($result['status'] == 1) {
                return $result['request'];
            } elseif ($result['request'] == 'CAPCHA_NOT_READY') {
                continue;
            } else {
                throw new Exception("Error while solving captcha: " . $result['request']);
            }
        }
    }

    function solveRecaptchaV3($apiKey, $siteKey, $url, $action = 'verify', $minScore = 0.3) {
        $requestUrl = "http://2captcha.com/in.php?key={$apiKey}&method=userrecaptcha&googlekey={$siteKey}&pageurl={$url}&version=v3&action={$action}&min_score={$minScore}&json=1";

        $response = file_get_contents($requestUrl);
        $result = json_decode($response, true);

        if ($result['status'] != 1) {
            throw new Exception("Error when sending captcha: " . $result['request']);
        }

        $captchaId = $result['request'];

        while (true) {
            sleep(5);
            $resultUrl = "http://2captcha.com/res.php?key={$apiKey}&action=get&id={$captchaId}&json=1";
            $response = file_get_contents($resultUrl);
            $result = json_decode($response, true);

            if ($result['status'] == 1) {
                return $result['request'];
            } elseif ($result['request'] == 'CAPCHA_NOT_READY') {
                continue;
            } else {
                throw new Exception("Error while solving captcha: " . $result['request']);
            }
        }
    }

    // Usage example for reCAPTCHA v2
    $apiKey = 'YOUR_API_KEY_2CAPTCHA';
    $siteKeyV2 = 'YOUR_SITE_KEY_V2';
    $urlV2 = 'https://example.com';

    try {
        $tokenV2 = solveRecaptchaV2($apiKey, $siteKeyV2, $urlV2);
        echo "Received token for reCAPTCHA v2: {$tokenV2}\n";
    } catch (Exception $e) {
        echo "Error: " . $e->getMessage() . "\n";
    }

    // Usage example for reCAPTCHA v3
    $siteKeyV3 = 'YOUR_SITE_KEY_V3';
    $urlV3 = 'https://example.com';
    $action = 'homepage'; // Specify the appropriate action
    $MinScore = 0.5; // Specify the minimum allowed score

    try {
        $tokenV3 = solveRecaptchaV3($apiKey, $siteKeyV3, $urlV3, $action, $minScore);
        echo "Received token for reCAPTCHA v3: {$tokenV3}\n";
    } catch (Exception $e) {
        echo "Error: " . $e->getMessage() . "\n";
    }

    ?>

    I also remind you of the need to replace some parameters in the code, in particular:
    $apiKey = 'YOUR_API_KEY_2CAPTCHA';
    $siteKeyV2 = 'YOUR_SITE_KEY_V2';
    $urlV2 = 'https://example.com';

Thus, using the examples given, you can solve most of the issues related to reCAPTCHA recognition. You can ask questions in the comments if there are any left!

Top modules for reCAPTCHA recognition in Python, Node js, and PHP

2captcha — Mon, 02 Sep 2024 09:27:46 +0000

In our age of automation, most solutions can be freely found available, and I'm not talking about solving math problems right now, but slightly more complex tasks, such as data parsing, and, as in our case, reCAPTCHA recognition. But how do I find a good module? After all, with access to technology, everyone got it, both conscientious developers and outright scammers.

I analyzed the market for captcha recognition modules and I got the top of modules in three popular programming languages. Let's get to the business!

Modules for solving reCAPTCHA in Python

The most popular programming language is definitely Python, the code for this programming language is searched in 5 out of 10 cases when people google "How to bypass reCAPTCHA" on the Internet (not taking into account queries that contain the word python, such as "how to bypass reCAPTCHA in python", and so on).

• 2captcha-python

• 2captcha-solver

• captchatools

• twocaptcha-extension-python

• Captcha-Tools

2captcha-python

The official module from the captcha recognition service 2captcha is designed for easy integration with their API. The module has advanced functionality and supports proxy configuration. The module is maintained and regularly updated, and can be used for parsing web resources and automation.

The service is ideal for users that focus on reliability in captcha recognition, as well as those who need official support from the 2captcha service.

The module supports asynchronous operations.

2captcha-solver

A module for solving reCAPTCHA and some other popular captchas (reCAPTCHA (v2, v3), FunCaptcha, and hCaptcha). Its main difference from the previous module is that it is more narrowly focused (supports fewer captchas) and can respond less flexibly to updates from the reCAPTCHA, compared with the previous official module.

2Captcha-solver supports proxy configuration and is especially useful for tasks requiring high performance, thanks to its support for asynchronous operations, which allows you to simultaneously solve multiple reCAPTCHAs.

captchatools

A multifunctional module, the main focus of which is on supporting several captcha recognition services. The functionality of the module is approximately similar to the previous two, it supports proxy configuration and asynchronous operations.

Based on the fact that the module allows you to integrate captcha recognition through several services, it has a unique function – brute force search for services. That is, you can use one service as the main one, and others as backup, and when, for example, you run out of funds on the main service, or if the main service could not cope with the task, the captcha will go to the backup one and will be solved. This way your script will be more automated and will not depend on the stability of one particular service.

Twocaptcha-extension-python

It is a narrowly focused module that is used for easy integration with Selenium and Playwright, and supports all types of reCAPTCHA.

The module can be used without the need to install additional extensions and only the API key is required for the start.

Captcha-Tools

A module that resembles captchatools in functionality, and it can be called an analog of the specified service. That is, you can use one of them by choice.

All the characteristics are the same: support for multiple services, brute force search for services in the process of captcha recognition, asynchronous operations, proxy configuration. It's all here, too. Only the developer is different.

Well, and an assumption from me, most likely both of these services will react a little slower to changes that occur in captcha recognition services and which are made by captcha developers than the official modules.

Modules for solving reCAPTCHA in node js

The second most popular language for which users are looking to find ways to bypass reCAPTCHA is node js, about 3 out of 10 requests to bypass reCAPTCHA come to this programming language.

As in the case of Python, it is easiest to recognize reCAPTCHA through special modules, especially since captcha recognition services are interested in simplifying work for their customers and many create and maintain such modules, here is a list of the most popular of them.

• 2captcha

• 2captcha-javascript

• captcha-solver

• multi-captcha-solver-adapter

2captcha

The official module for node js from the captcha recognition service 2captcha, supports most of the known types of captcha, including reCAPTCHA. An important difference between this module and the others is TypeScript support, which makes it convenient for development of various applications.

All basic settings, including asynchronous operations, proxy settings, etc. are present in the module, which makes it a universal module for solving most types of captcha. Well, and the fact that the module was created by the 2captcha service allows us to draw a conclusion about its reliability.

2captcha-javascript

It is also the official module for recognizing the main types of captcha from the 2captcha service, and it supports all the same settings as the previous module (with the exception of TypeScript support), but it seemed to me that it was created more with an emphasis on ease of integration and a quick start.

It is easier than the previous one and, like its predecessor, it solves the main task – bypasses reCAPTCHA. So, if you just need your script (program) written in node js to solve reCAPTCHA, use this module, and if you need deeper integration, take a closer look at the previous module.

captcha-solver

The module is tailored for integration with Puppeteer and allows you to solve reCAPTCHA and other popular types of captcha.

In addition to the fact that this module is tailored for Puppeteer, it provides the opportunity to choose a provider that solves the captcha, which also allows you to configure a brute force search for services (as described in the section about modules for Python).

Multi-captcha-solver-adapter

A module from third-party developers that supports the reCAPTCHA solution, as well as some other popular types of captcha. Several captcha recognition services are integrated in the module, which allows you to configure a brute force search for services (make one the main one, and make the rest backup ones)

Modules for solving reCAPTCHA in PHP

And the third most popular language for which users are looking to find ways to bypass reCAPTCHA is php. I suggest to start with modules, as in the first two cases, and to end with the code. So, the most popular modules for solving reCAPTCHA in PHP are the following:

2captcha-php

php-captcha-solver

2captcha-php

This module makes it easy to integrate the 2Captcha API into your PHP CAPTCHA solution code. It supports CAPTCHA types such as reCAPTCHA, FunCaptcha, GeeTest, and others. The module is designed for quick setup and use, including support for text CAPTCHA and reCAPTCHA v3. It also supports various methods for working with images and audio files.

Php-captcha-solver

A module that provides a user-friendly interface for integration with various CAPTCHA services, including 2Captcha. Supports various types of CAPTCHA, such as reCAPTCHA and FunCaptcha. This module is focused on ease of use and quick setup.

In fact, if we compare these two modules, the first one is developed by the 2captcha service, and the second one is made by the developer community, and both solve the same tasks and have approximately the same set of functionality. However, the second module may be less prompt in terms of updates, unlike the official module.

Thus, using the given examples of modules in popular programming languages, you can solve most of the issues related to reCAPTCHA recognition. You can ask questions in the comments if there are any left!

Data labeling – training on cats

2captcha — Mon, 29 Jul 2024 07:00:59 +0000

At some point while diving deeper into automation processes you are faced with the need for data labeling, although just a couple of weeks ago, the phrases data labeling and you were standing at a party called "Earnings on the Internet" in different rooms. Or it would be better to say that you were standing by the pool, and the data labeling was on the third floor, smoking on the balcony with experts in the field of machine learning. How did we meet? Probably, someone pushed it off the balcony into the pool, and I helped it out, soaking my clothes along the way.

And so, you are sitting in the kitchen, smoking one cigarette for two and trying to figure out what each of you do, and how you could be useful to each other.

In general, it's not so important why I needed it, but the fact that I succeeded is much more interesting. And now that you are already bored enough (or not), let's get to the point.

The task

The title has the phrase – training on cats – and it is not a metaphor. This is a direct indication of what needs to be done. It is necessary to determine what is depicted in the photo (which animal), and what the customer will do with this information is the third thing.

The task, technically, is as clear as possible. And most importantly, it is as simple as possible. Now we just need to implement it. And we will do this through the data labeling service. Really, I can't write all sorts of labeling programs manually, right? And I also do not know how to.

In general, we are following the path of simplification.

So, we have the task, we have the solution, let's get to the details:

At the input, we submit a set of photos and pictures depicting various animals. The task is to get a textual description of the animal depicted in the image as the response. The data volume is big, so uploading this volume manually is not an option. We will send all this via API, for which we write a simple script.

The script

First, we need to import the necessary libraries. In our script, we will use requests to make HTTP requests, base64 to encode images, os to work with the file system, and json to process JSON data.

import requests
import base64
import os
import json

A function for creating the task

Now we'll write a function that will create a task for the server of the data labeling service. It will be the create_task function. It will accept the API URL, project ID, path to the image, and the API key.

Execution Steps:

Opening the image and encoding it in base64.
Forming the task specification (task_spec) containing the encoded image.
Creating a payload for the request.
Setting the request headers, including the API key.
Sending a POST request to the 2Captcha server.
Processing the server response and returning the result.

def create_task(api_url, project_id, image_path, api_key):
    try:
        with open(image_path, "rb") as image_file:
            encoded_image = base64.b64encode(image_file.read()).decode('utf-8')
            image_data = f"data:image/jpeg;base64,{encoded_image}"

        task_spec = [
            {
                "image_with_animal": image_data
            }
        ]

        payload = {
            "project_id": project_id,
            "task_spec": task_spec  # Array with one object inside 
        } 

        headers = { 
            "Content-Type": "application/json",
            "Authorization": f"{api_key}" 
        } 

        print("Data to be sent:", json.dumps(payload, indent=4))  # Logging data before sending 

        response = requests.post(api_url + "/tasks", json=payload, headers=headers)

        if response.status_code == 201: 
            print(f"The task was successfully created for the file {image_path}")
            return True 
        else: 
            print(f"Error when creating a task for the file {image_path}: {response.status_code}, {response.text}")
            return False 
    except Exception as e: 
        print(f"An error occurred when creating a task for the file {image_path}: {str(e)}")
        return False

A function to check the validity of the project ID

During the testing of the script, I had to create a foolproof protection. The validate_project_id function checks whether the specified project ID is correct. It sends a GET request to the service server and returns the verification result.

def validate_project_id(api_url, project_id, api_key):
    headers = {
        "Authorization": f"{api_key}"
    }
    response = requests.get(f"{api_url}/projects/{project_id}", headers=headers)
    return response.status_code == 200

Image processing function

Since the images will not be uploaded to the project immediately, but will be fed there in some portions, a function to process and check the images for repetition was required. The process_images function processes all images in the specified directory. It checks the validity of the project ID, reads the images, checks if they have already been sent, and creates tasks for new images.

Execution Steps:

Checking the validity of the project ID.
Loading the history of sent images.
Iterating through all files in the specified directory.
Checking whether the file is an image and whether it's been sent earlier.
Creating a task for each new image.
Updating the history of sent images.

def process_images(api_url, project_id, images_dir, api_key):
    try:
        if not validate_project_id(api_url, project_id, api_key):
            print(f"Incorrect `project_id`: {project_id}")
            return 

        sent_images = set() 
        # File for storing sent images 
        history_file = "sent_images.json" 

        # Loading the history of sent images if the file exists 
        if os.path.exists(history_file):
            with open(history_file, "r") as file:
                sent_images = set(json.load(file))

        # Going through all files in the directory 
        for filename in os.listdir(images_dir):
            image_path = os.path.join(images_dir, filename) 
            # Checking if the file is an image and if it's been sent earlier 
            if os.path.isfile(image_path) and filename.lower().endswith(('.png', '.jpg', '.jpeg')) and filename not in sent_images:
                print(f"File processing: {image_path}")
                if create_task(api_url, project_id, image_path, api_key):
                    sent_images.add(filename) 

        # Updating the history of sent images 
        with open(history_file, "w") as file: 
            json.dump(list(sent_images), file) 
            print("Process completed successfully.") 
except Exception as e: 
            print(f"An error occurred while processing images: {str(e)}")

The main block of the program

In the main block of the program, we set the parameters: API URL, project ID, directory with images, and the API key. Then we call the process_images function.

# Example of using the function
if __name__ == "__main__":
    api_url = "http://dataapi.2captcha.com " # Updated API URL for creating tasks 
    project_id = 64 # Replace with your project ID
    images_dir = "C:/images " # Specify the directory with images 
    api_key = "Your API key" # Replace with your API key 

    # Check for images in the directory 
    if not os.path.isdir(images_dir):
        print(f"The directory {images_dir} does not exist")
    else:
        image_files = [f for f in os.listdir(images_dir) if f.lower().endswith(('.png', '.jpg', '.jpeg'))]
        if not image_files:
            print(f"There are no images to process in the directory {images_dir}")
        else: 
            print(f"Found {len(image_files)} images for processing")
            process_images(api_url, project_id, images_dir, api_key)

This way I got a Python script that automates the process of creating tasks on the data labeling platform. The script reads the images from the directory, encodes them in base64, sends them to the server, and saves the history of the sent images. You can see the whole script below.

`
import requests
import base64
import os
import json

def create_task(api_url, project_id, image_path, api_key):
try:
with open(image_path, "rb") as image_file:
encoded_image = base64.b64encode(image_file.read()).decode('utf-8')
image_data = f"data:image/jpeg;base64,{encoded_image}"

    task_spec = [
        {
            "image_with_animal": image_data
        }
    ]

    payload = {
        "project_id": project_id,
        "task_spec": task_spec  # Array with one object inside 
    } 

    headers = { 
        "Content-Type": "application/json",
        "Authorization": f"{api_key}" 
    } 

    print("Data to be sent:", json.dumps(payload, indent=4))  # Logging data before sending 

    response = requests.post(api_url + "/tasks", json=payload, headers=headers)

    if response.status_code == 201: 
        print(f"The task was successfully created for the file {image_path}")
        return True 
    else: 
        print(f"An error occurred when creating a task for the file {image_path}: {response.status_code}, {response.text}")
        return False 
except Exception as e: 
    print(f"An error occurred when creating a task for the file {image_path}: {str(e)}")
    return False

def validate_project_id(api_url, project_id, api_key):
headers = {
"Authorization": f"{api_key}"
}
response = requests.get(f"{api_url}/projects/{project_id}", headers=headers)
return response.status_code == 200

def process_images(api_url, project_id, images_dir, api_key):
try:
if not validate_project_id(api_url, project_id, api_key):
print(f"Incorrect project_id: {project_id}")
return

sent_images = set() 
# File for storing sent images 
history_file = "sent_images.json" 

# Loading the history of sent images if the file exists 
if os.path.exists(history_file):
        with open(history_file, "r") as file:
            sent_images = set(json.load(file))

# Going through all files in the directory 
for filename in os.listdir(images_dir):
        image_path = os.path.join(images_dir, filename) 
        # Checking if the file is an image and if it's been sent earlier 
        if os.path.isfile(image_path) and filename.lower().endswith(('.png', '.jpg', '.jpeg')) and filename not in sent_images:
            print(f"File processing: {image_path}")
            if create_task(api_url, project_id, image_path, api_key):
                sent_images.add(filename) 

# Updating the history of sent images 
with open(history_file, "w") as file: 
    json.dump(list(sent_images), file) 
print("Process completed successfully.")

except Exception as e:
print(f"An error occurred while processing images: {str(e)}")

Example of using the function

if name == "main":
api_url = "http://dataapi.2captcha.com " # Updated API URL for creating tasks
project_id = 64 # Replace with your project ID
images_dir = "C:/images " # Specify the directory with images
api_key = "Your API key" # Replace with your API key

# Checking for images in the directory 
if not os.path.isdir(images_dir):
    print(f"The directory {images_dir} does not exist")
else:
    image_files = [f for f in os.listdir(images_dir) if f.lower().endswith(('.png', '.jpg', '.jpeg'))]
    if not image_files:
        print(f"There are no images to process in the directory {images_dir}")
    else: 
        print(f"Found {len(image_files)} images for processing")
        process_images(api_url, project_id, images_dir, api_key)

https://youtu.be/n4qyOXrnE6A

Configuring the script

Now, in order for the script to work, you need to prepare everything:
We create a folder where we create a file with an extension.py and call it what you like. I'm not very imaginative, so it will be script.py
Also, we create a subfolder in the folder where our images will be stored. The path to this folder is written in the script – line 84.
Now we need the API key, API URL, and the project number – lines 85, 82, and 83 in the script, respectively.

We collect all this in the data labeling service.
The API key and the project number are in your dashboard.

And we take the API URL from the API documentation of the service, but I have already written it for you in the script. However, if you need something more complex than labeling animals, you can study it for your own interest.

Also you need to create the project itself in the service so that there is a place to which you send images. In theory, it is possible to send everything through the API, but even I freaked out and did it all manually. If you want, you can figure out how to send everything through the API on your own.

So, we click on the "Add project" button

We fill in the fields "Title", "Description", and "Public description". The difference between a description and a public description is that the first one is a short description, and the public one is a description of the task. Don't ask me why, it's beyond my competence.

We select the language (1) and create two specifications (2 and 3). (2) – these are the fields for sending images. There are only two options – an image or a text, in our case, we need to send images, so we choose an image.

(3) – These are the fields for the worker, so, in fact, these are the fields where it will write an answer for us (the label of the animal). Since I need it to write me an answer to what kind of animal is depicted in the picture, I use Input. In addition to input, there is also a select, radio, and checkbox. In general, there are plenty to choose from.

In the screenshot below, you can see the "Required" checkbox picked – this is a kind of protection for yourself (double control) – to avoid sending an empty task. That is, if it is checked, the task will not be created until the condition is met (in our case, the presence of an image).

There is still the possibility of getting the result of the responses directly to the server, but I did not need it. It will probably be needed soon, but not this time.

Actually, that's it, we save the project, copy its number and paste it into the script (line 83), and you can run it! We run it with the command python script.py in the developer console.

Then the task flies away to the worker and after it is solved, the answers appear in the personal account in this format

So, this is it, the task is solved.

CacheBrowser: Bypassing the Chinese Firewall Without Proxies

2captcha — Wed, 17 Jul 2024 12:05:17 +0000

Content Delivery Networks (CDNs) play a crucial role in the distribution of internet traffic, yet little is known about how internet censors, especially in countries like China, manage to control CDN content. Researchers from the University of Massachusetts have tackled this issue, developing CacheBrowser, an innovative tool to bypass such censorship without relying on proxies. This article delves into their findings and the implications for internet freedom.

We (specialists from proxy service) have prepared an overview material with the main conclusions and results of this experiment (translate of this material).

The Problem of Internet Censorship and CDNs

Internet censorship is a significant threat to free speech and access to information. Traditional methods of internet communication, rooted in the end-to-end model from the 1970s, make it easy for censors to block access based on IP addresses. However, the rise of CDNs has introduced new challenges and opportunities.

CDNs, such as Akamai, handle a substantial portion of global internet traffic by caching content on geographically distributed servers. This not only improves user experience but also helps content creators scale their operations efficiently.

Techniques for Censoring CDN Content

The University of Massachusetts study outlines several censorship techniques applied to CDNs, focusing on the methods used by Chinese authorities:

IP Filtering

Method: Blacklisting IP addresses of servers hosting prohibited content.
Challenges: Due to the distributed nature of CDNs, blocking one IP is ineffective. CDNs use numerous edge servers, making it difficult for censors to block all relevant IPs without affecting allowed content.

DNS Interference

  **Method:** Preventing users from resolving domain names of prohibited sites using DNS poisoning or manipulation.

Challenges: Users can bypass this method with non-standard DNS resolution techniques. Combining DNS blocking with IP filtering is also ineffective against CDNs.

Deep Packet Inspection (DPI)

Method: Analyzing data packets for specific URLs or keywords and blocking them.
Challenges: DPI is resource-intensive and can be thwarted by encryption methods like HTTPS.

Self-Censorship by CDN Providers

  **Method:** States can pressure CDN providers to comply with local censorship laws.

Challenges: Providers often comply to maintain market presence, leading to self-censorship.

China’s Approach to CDN Censorship

China’s Great Firewall is one of the most advanced censorship systems globally. Researchers conducted experiments using a Linux node within China, confirming it experienced similar censorship to typical Chinese users. They analyzed blocking methods for various CDN providers, including Akamai, CloudFlare, and Amazon CloudFront.

Key Findings:

Akamai’s Self-Censorship: In China, Akamai blocks access to prohibited content while allowing access outside the country.
DNS Filtering: The primary method used for other CDN providers involved resolving DNS requests for blocked sites to incorrect IP addresses.
Encryption and HTTPS: While DPI can block unencrypted traffic, HTTPS forces censors to block entire domains, inadvertently affecting allowed content.

CacheBrowser: Bypassing Censorship Without Proxies

Given the challenges in blocking CDN content, researchers developed CacheBrowser, a tool that bypasses censorship by leveraging CDN properties. Unlike traditional methods that rely on proxies, CacheBrowser directly accesses edge servers where content is cached.

How CacheBrowser Works:

Client Software: Installed on the user’s computer, CacheBrowser uses a standard browser for content access.
LocalDNS System: Intercepts DNS requests locally, reducing dependency on traditional DNS resolution.
Scraper and Resolver Modules: Identify blocked domains and resolve them through non-standard methods, updating the LocalDNS database.
Bootstrapper Module: Uses geographically distributed DNS servers to ensure resolution, bypassing local censorship.

In practice, CacheBrowser allows users to access blocked content by contacting edge servers directly, using IP addresses obtained through alternative means. This method proved effective even in accessing heavily censored sites like Facebook from within China.

Conclusion

The CacheBrowser experiment demonstrates a viable method for bypassing internet censorship by exploiting the inherent properties of CDNs. This tool offers a promising solution for accessing restricted content in regions with stringent censorship, like China. By understanding and leveraging the weaknesses in traditional censorship techniques, CacheBrowser provides a pathway to maintaining free access to information on the internet.

Six Ways to Use Residential Proxies for Corporate Objectives

2captcha — Mon, 20 May 2024 07:45:34 +0000

Residential proxies can play a crucial role in solving various corporate challenges, from accessing geo-restricted content to enhancing security measures. Here’s how businesses can leverage this technology effectively.

1. Competitive Intelligence

Overview:
Residential proxies allow businesses to gather competitive intelligence by masking their IP addresses as those of real users. This helps in collecting data from competitors' websites without being blocked.

Use Case:
Companies can monitor competitor pricing, promotions, and new product releases. For instance, an e-commerce company can track prices across different platforms to adjust its own pricing strategy accordingly.

2. Brand Protection

Overview:
Residential proxies are effective in combating counterfeit products. By using IP addresses from specific regions, companies can identify and take action against unauthorized sellers.

Use Case:
Pharmaceutical companies can detect counterfeit drug sellers by accessing their websites through proxies that appear as local users, making it easier to gather evidence and take legal actions.

3. Testing and Performance Monitoring

Overview:
Using residential proxies, businesses can test new website features and monitor performance from different geographical locations. This ensures that users across the globe have a consistent experience.

Use Case:
A global SaaS company can simulate user interactions from various regions to test website load times and functionality, ensuring optimal performance for users worldwide.

4. Marketing and Advertising Optimization

Overview:
Residential proxies enable businesses to view how their advertisements appear in different regions and optimize their marketing strategies accordingly. This includes analyzing competitors' ads and their effectiveness.

Use Case:
A digital marketing agency can use proxies to verify that ads are being displayed correctly in target regions, ensuring the ad spend is effectively utilized and tweaking campaigns based on local performance data.

5. Content Aggregation

Overview:
Businesses that aggregate content from multiple sources can use residential proxies to avoid anti-bot measures, ensuring continuous data collection without interruptions.

Use Case:
A price comparison website can use proxies to gather real-time data on product prices from various e-commerce platforms, keeping their database updated and accurate.

6. Custom Data Collection and Analysis

Overview:
Residential proxies are essential for companies that specialize in large-scale data collection and analysis, as they help avoid detection and blocking by websites.

Use Case:
A market research firm can use proxies to collect vast amounts of data from different online sources for analysis, aiding in producing comprehensive market insights.

Residential proxies offer businesses a way to mimic real user behavior, providing access to restricted data and ensuring the smooth operation of various online activities. By integrating residential proxies into their strategies, companies can enhance data collection, protect their brand, and optimize marketing efforts.

How to set up a proxy for the Google Chrome browser – step-by-step instructions

2captcha — Mon, 22 Apr 2024 08:38:15 +0000

Often, to solve various tasks, you need to use a proxy server, which allows, for example, to study search results through the eyes of a person from another region or even a country. But for an ordinary Internet user, setting up a proxy for Google Chrome may seem to be quite a complicated process (at first thought), but in fact it is no more difficult than installing wallpaper on the main screen of your computer.

There are no settings that allow you to install a proxy inside the Google Chrome browser itself. The settings of your operating system have to be used, and now we will figure out how to deal with that.
Before setting up a proxy for Google Chrome, you need to get these proxies. There are many free services, but we recommend using paid proxies, as they are more secure and work faster.

Where do we get a proxy?

Using the example of 2Captcha residential proxies, we will tell you where to get a proxy.
If you do not have an account on the 2Captcha service yet, register there and log in to your personal account.
Top up your balance, then click on the "Proxy" button on the left.

You will be sent to the page with the 2Captcha residential proxies. In the right sidebar you will see a window for the proxy region selection; select the country, the region, and the city you need there. If you don't need to be linked to a specific city or region, you can choose a country or even a mix of countries from a specified region. In the "IP lifetime" box, set a number (no more than 120), this is the time after which reconnection to a new IP address from your chosen region will take place.

Click on the "Generate" button.

Your proxies are ready – now you just need to configure them for the Chrome browser.

In the center of the page you can see the necessary data – "Login", "Password", and "Host" –that's all you need. You can save them in a separate file for convenience, or use your client area.

If you want to use a proxy for only one browser, you will need an Antidetect Browser, for example Dolphin Anti or Indigo.

Step-by-step instructions for setting up a proxy

Go to the settings of your operating system, click on the "Start" button and then click on the gear sign on the left.

Next, select the section – "Network and Internet"

The "Proxy server" button is on the bottom left.

You need the section – "Configuring the proxy manually". Turn the "Use proxy server" checkbox to the "On" position.

Enter the Address and port in the specified fields and click on the "Save" button.

The proxy settings are applied, now you just need to enter your login and password (if you use paid proxies). The first time you try to access the Internet, a field for entering your login and password will appear, after entering them you will be able to use the Internet.

For the purity of the experiment, you can check which IP address is used for you by typing the query "My IP" in the Google search engine, and you will see the result on any checker.

A detailed video instruction describing the proxy set up process for Google Chrome is attached below.

https://www.youtube.com/watch?v=ZC7bh15EJlw

And more useful videos can be found on our YouTube channel. Also, we have a library on Github.

Solving Amazon captcha Waf Captcha fully automatically with almost zero experience in development

2captcha — Tue, 12 Mar 2024 06:08:37 +0000

Disclaimer:
Dear followers!
We'd like to share an insightful article, detailing effective methods for solving CAPTCHA on the Amazon platform. While this article isn't authored by us, we believe it's important to share valuable information with our community. We hope you find this article helpful and engaging!

A small epigraph - if you are making an instruction, then do it to the end, otherwise instructions on how to solve the Amazon captcha for junior developer will be as clear as mud.

What's it all about? When I needed to solve a captcha from Amazon, the notorious Waf Captcha, I started looking for information at a service that I constantly use when I work with GSA Ranker and some other services (2captcha).

I found instructions there and posted the link to it above. As you probably understood from the epigraph, I didn’t understand a thing, or rather, I understood that I needed to use the API, but that’s all...

It was much easier with Selenium

The main issue is the short timeout given for a solution from Amazon's side. The time to solve the captcha is limited, and if there's no response, the captcha refreshes (two of its parameters get updated - iv and context)

It turns out the captcha freshness timeout is about 30 seconds, and in that time, you need to find the parameters on the page, copy them, paste them into the script code, and run it. After that, 2captcha should solve it and return the correct answer. I tried to do this for a couple of fruitless hours, developing a routine of actions, but alas, searching for and replacing the changing parameters takes at least 12-15 seconds, leaving only 15 to 18 seconds for the captcha to be solved by the service, which in current realities sounds quite fantastical.

We need a different approach here, the script should search for and insert the parameters, but how can someone who's never dealt with anything more complex than Ahrefs in their life write it? That's exactly why I think instructions like those mentioned in the article need to be more detailed than just "Just use the API, are you completely nuts?"

Solution

After all the solution was found, and it took me about 3 hours. Let me tell you how a junior developer can solve the Amazon captcha fully automatically.

You'll need GPT Chat, and in my case, video recognition for Amazon captcha (you won't need this, as I'll give you the ready-made file).

I got the video from a friend who is a programmer, but he did not allow me to make it public, as it wasn't anonymized.
However, you'll keep nagging me for proofs, and then I'll end up on antidepressants because no one believes me, so I reproduced this video at the very end, when I got the final script, and will happily attach it at the end of this text, as a demonstration of my endless dedication to the audience!

So, let’s do it step by step.

I took the video, made 3 screenshots, uploaded them to GPT Chat, and asked it to transcribe this code into text for me.

The video contained several files but showed only the contents of 2 of them - index.js and inject.js - which is where I started.
I won't bore you with the details of deciphering the screenshots (it was a bit of a hassle to compile the code from the screenshots into one unit but in the end, I got these two pieces of code for the two files:

// index.js
import { launch } from 'puppeteer'
import { Captcha } from '2captcha-ts'
import { readFileSync } from 'fs'

const solver = new Captcha(process.env.APIKEY)

const target = 'URL of website where you faced CAPTCHA'

const example = async () => {
  const browser = await launch({
    headless: false,
    devtools: true
  })

  const [page] = await browser.pages()

  const preloadFile = readFileSync('./inject.js', 'utf8')
  await page.evaluateOnNewDocument(preloadFile)

  // Here we intercept the console messages to catch the message logged by inject.js script
  page.on('console', async (msg) => {
    const txt = msg.text()
    if (txt.includes('intercepted-params:')) {
      const params = JSON.parse(txt.replace('intercepted-params:', ''))

      const wafParams = {
        pageurl: target,
        sitekey: params.key,
        iv: params.iv,
        context: params.context,
        challenge_script: params.challenge_script,
        captcha_script: params.captcha_script
      }
      console.log(wafParams)

      try {
        console.log('Solving the captcha...')
        const res = await solver.solveRecaptchaV2(wafParams)
        console.log(`Solved the captcha ${res.id}`)
        console.log(res)
        console.log('Using the token...')
        await page.evaluate(token => {
          window.localStorage.inputCaptchaToken(token)
        }, res.data.captcha.voucher)
        console.log(e)
      } catch (e) {
        console.log(e)
      }
    }
  })

  await page.goto(target)
  // Additional code to interact with the page after captcha is solved might be here...
}

example()

And the second file, inject.js

console.clear = () => console.log('Console was cleared')

const i = setInterval(() => {
  if (window.CaptchaScript) {
    clearInterval(i)

    let params = gokProps

    Array.from(document.querySelectorAll('script')).forEach(s => {
      const src = s.getAttribute('src')
      if (src && src.includes('captcha.js')) params.captcha_script = src
      if (src && src.includes('challenge.js')) params.challenge_script = src
    })

    console.log('intercepted-params: ' + JSON.stringify(params))
  }
}, 5)

I asked the Chat how to make the code work, and I was advised to use the standard command.

node index.js

But I've been around these internet streets for a long time, and I understand that the code won't just work like that if the necessary libraries aren't installed on the computer. My neuro-consultant helped me out here too.

After examining the code, I gave him in the form of screenshots, he recommended installing the following packages:

puppeteer

2captcha-ts

Honestly, I didn't quite understand why playwright is needed here, but who am I to doubt the competence of the Chat.

As such, the installation code is npm install puppeteer 2captcha-ts playwright (though I couldn't install them all together using VS Code, probably because of my clumsy hands, I installed them one by using the console).

npm install puppeteer
npm install 2captcha-ts
Next is where it gets interesting, because everything up to this point I know one way or another, but the next block is a real mystery to me, and I just do what my neuro-consultant tells me.

So, for the code to work correctly, a file with the .env extension was needed. It can be unnamed, but it should contain the following data:

APIKEY=your_2captcha_api_key
It is understood that instead of the "your_2captcha_api_key" parameter, I inserted my own key from the service.

There were 6 more recommendations on what to do to make the code work, but...

So, the first run and the first error occurred.

The error was related to using syntax ES6 import in Node.js. To use it, you either need to specify the module type in package.json or change the file extension to .mjs.

I was too lazy to specify the module type in package.json, so I took the path of least resistance and simply renamed the file extension from .js to .mjs.

The next error was related to the imported package 2captcha-ts, but I don't want to go into detail about it. I'll just say that I changed the code responsible for running this module several times, added logging, and checked the correctness of connecting the .env file.

Still, it didn't work. The script kept throwing errors and stubbornly refused to run. I compared the screenshot and the code extracted from it by the Chat and found a small typo, which turned out to be the root of the problem.

As it turned out, even that didn't help - an error occurred saying APIKEY is not defined in .env file

We fixed this by adding a new package:

dotenv

npm install dotenv

After that, I encountered a couple more typos, which the Chat tried to solve by changing the code structure, but I just needed to carefully compare the screenshot and the code itself.

In the end, the code of the index.js file looked like this:

// index.js
import { launch } from 'puppeteer'
import { Captcha } from '2captcha-ts'
import { readFileSync } from 'fs'

const solver = new Captcha(process.env.APIKEY)

const target = 'URL of website where you faced CAPTCHA'

const example = async () => {
  const browser = await launch({
    headless: false,
    devtools: true
  })

  const [page] = await browser.pages()

  const preloadFile = readFileSync('./inject.js', 'utf8')
  await page.evaluateOnNewDocument(preloadFile)

  // Here we intercept the console messages to catch the message logged by inject.js script
  page.on('console', async (msg) => {
    const txt = msg.text()
    if (txt.includes('intercepted-params:')) {
      const params = JSON.parse(txt.replace('intercepted-params:', ''))

      const wafParams = {
        pageurl: target,
        sitekey: params.key,
        iv: params.iv,
        context: params.context,
        challenge_script: params.challenge_script,
        captcha_script: params.captcha_script
      }
      console.log(wafParams)

      try {
        console.log('Solving the captcha...')
        const res = await solver.solveRecaptchaV2(wafParams)
        console.log(`Solved the captcha ${res.id}`)
        console.log(res)
        console.log('Using the token...')
        await page.evaluate(token => {
          window.localStorage.inputCaptchaToken(token)
        }, res.data.captcha.voucher)
        console.log(e)
      } catch (e) {
        console.log(e)
      }
    }
  })

  await page.goto(target)
  // Additional code to interact with the page after captcha is solved might be here...
}

example()

Turned into the following index.mjs

// index.js
import 'dotenv/config';
import { launch } from 'puppeteer'
import Captcha from '2captcha-ts';
import { readFileSync } from 'fs'

if (!process.env.APIKEY) {
    console.error("APIKEY is not defined in .env file");
    process.exit(1); // Terminate execution if key not found
}

const solver = new Captcha.Solver(process.env.APIKEY);

const target = 'URL of website where you faced CAPTCHA'

const example = async () => {
    const browser = await launch({
        headless: false,
        devtools: true
    })

    const [page] = await browser.pages()

    const preloadFile = readFileSync('./inject.js', 'utf8')
    await page.evaluateOnNewDocument(preloadFile)

    // Here we intercept the console messages to catch the message logged by inject.js script
    page.on('console', async (msg) => {
        const txt = msg.text()
        if (txt.includes('intercepted-params:')) {
            const params = JSON.parse(txt.replace('intercepted-params:', ''))

            const wafParams = {
                pageurl: target,
                sitekey: params.key,
                iv: params.iv,
                context: params.context,
                challenge_script: params.challenge_script,
                captcha_script: params.captcha_script
            }
            console.log(wafParams)

            try {
                console.log('Solving the captcha...')
                const res = await solver.amazonWaf(wafParams)
                console.log(`Solved the captcha ${res.id}`)
                console.log(res)
                console.log('Using the token...')
                await page.evaluate(async (token) => {
                    await ChallengeScript.submitCaptcha(token);
                    window.location.reload ()
                }, res.data.captcha_voucher);
            } catch (e) {
                console.log(e)
            }
        } else {
            return
        }
    })

    await page.goto(target)
    // Additional code to interact with the page after captcha is solved might be here...
}

example()

In the code above, don't forget to substitute the correct URL where the solution is needed (if you decide to apply it).

From this inject.js:

console.clear = () => console.log('Console was cleared')

const i = setInterval(() => {
  if (window.CaptchaScript) {
    clearInterval(i)

    let params = gokProps

    Array.from(document.querySelectorAll('script')).forEach(s => {
      const src = s.getAttribute('src')
      if (src && src.includes('captcha.js')) params.captcha_script = src
      if (src && src.includes('challenge.js')) params.challenge_script = src
    })

    console.log('intercepted-params: ' + JSON.stringify(params))
  }
}, 5)

Into this inject.js:

// console.clear = () => console.log('Console was cleared')

let counter = 0;
const MAX_ATTEMPTS = 2000; // Approximately 10 seconds at 5 ms intervals
console.log('Let's start searching for CaptchaScript...');

const i = setInterval(() => {
    console.log(`Attempt ${counter}: Checking for CaptchaScript...`);

    if (window.CaptchaScript || counter > MAX_ATTEMPTS) {
        clearInterval(i);
        if (!window.CaptchaScript) {
            console.log('CaptchaScript не найден');
        } else {
            console.log('CaptchaScript найден');

            let params = gokuProps;
            Array.from(document.querySelectorAll('script')).forEach(s => {
                const src = s.getAttribute('src');
                if (src && src.includes('captcha.js')) params.captcha_script = src;
                if (src && src.includes('challenge.js')) params.challenge_script = src;
            });

            console.log('intercepted-params: ' + JSON.stringify(params));
        }
    }
    counter++;
}, 5);

Finally, the script worked. In full. It solved the captcha and continues to solve it every time it runs.

https://www.youtube.com/watch?v=49vf0ob6xbY

Finally, the script worked. In full. It solved the captcha and continues to solve it every time it runs.

Looks like the future has arrived, buddy. But this is not certain.

What to do with this information? Well, darn it, I really like the advice - just live with it now. But I don't feel like giving advice. Have it your way, maybe someone will find it useful for their projects...

For more tips and tricks on CAPTCHA recognition, be sure to check out our YouTube channel where we delve deeper into this topic. Additionally, you can find even more ready-made solutions in our GitHub repository. Stay tuned for more insightful content and updates!

2captcha proxy review - new service

2captcha — Fri, 01 Mar 2024 07:16:08 +0000

We've launched a residential proxy service and we're excited to introduce it in detail.

Residential proxies differ from server proxies in that with residential proxies, all available IP addresses are tied to internet providers in different countries. This means that when using such proxies, your IP is associated with a real person's IP, which enhances security and trustworthiness for websites and services, allowing you to tackle more complex tasks.

Now, onto specifics - our residential proxy network covers over 220 countries, with a pool of over 90 million available IP addresses.

Getting started with the service is easy - if you have an account on our platform, all you need to purchase proxies is to ensure that your account balance is positive and has enough funds to cover the cost of the proxies.

With residential proxies, you're not purchasing a specific IP but rather traffic, within which you can use as many IP addresses as needed (they rotate). The price for one gigabyte of traffic is 5,5$, but with a larger order, you get a discount, which increases proportionally to the amount of traffic. For instance, when purchasing 100 gigabytes of traffic, the price per gigabyte will be 2,5$, which is 50% lower than purchasing 1 gigabyte separately.

As for settings, we offer the option to specify the country, region, or city when forming the pool of IP addresses. You can choose an IP address down to a specific city if needed, or use standard settings where the system mixes different countries. Additionally, you can use a mix of IP addresses from specific regions or countries, which is also convenient for certain tasks.

You can configure the rotation time for IPs, whether to change the address every minute or every two hours, with a one-minute adjustment step.

After purchasing traffic, you'll have the option to change your login and password (for authentication). By default, the system generates them automatically, but you can set ones that are convenient for you.

It's worth noting the presence of pre-configured settings for some popular anti-detection browsers. When selecting a specific browser, three URLs (http, https, Socks5) appear below, any of which you can copy and paste into the proxy configuration field in your chosen anti-detection browser.

Also, in your account, you'll find examples for integrating our residential proxies using popular programming languages. Code examples can be found at the bottom of the page.

Understanding Bounding Boxes: A Key Tool in Computer Vision and Machine Learning

2captcha — Thu, 16 Nov 2023 10:10:34 +0000

In the rapidly evolving field of computer vision, one of the fundamental tools used for object recognition and image classification is the bounding box. These rectangular outlines encapsulate objects or areas of interest within an image, forming the backbone of many machine learning projects.

More detailed information you can read on our article oriented bounding box what is it and how we can help you with it!

What are Bounding Boxes?

At its core, a bounding box is a simple concept: a rectangle drawn around an object in an image. This method is instrumental in annotating images for tasks such as object detection, a significant area in computer vision. The process involves marking the size and location of various objects, from people and animals to vehicles and buildings. In some cases, bounding boxes are rotated to better fit the object's shape, known as "oriented bounding boxes," a feature in advanced labeling tools. Besides marking locations, bounding boxes can carry additional information like object classes and attributes, enhancing the depth of data for machine learning models.

Their Role in Machine Learning

Machine learning models, like YOLO (You Only Look Once), rely on datasets annotated with bounding boxes for training and testing. These models learn to predict the positions and classes of objects in new, unseen images, making them crucial in developing intelligent systems.

Bounding Boxes and Data Annotation

In artificial intelligence applications, particularly in teaching machines to recognize and classify objects in images, bounding boxes are indispensable. They contribute to the data annotation process, adding essential context to raw data, which could be in various formats like images, text, or videos.

Computer Vision and Object Detection

In computer vision, bounding boxes are vital for object detection and localization. By providing explicit information about an object's location and size, they help create comprehensive datasets for machine learning algorithms, enabling these models to identify and classify objects accurately.

Practical Applications

From security cameras identifying potential threats to smartphone apps recognizing faces, bounding boxes play a pivotal role. They help in training algorithms to distinguish different objects in varied environments, a cornerstone of modern AI applications.

2Captcha’s Solution

2Captcha offers a robust bounding box data labeling API, tailor-made to meet the specific needs of data scientists. The service focuses on precision and high-quality annotation, essential for crafting cutting-edge machine learning models for computer vision.

Technical Aspects

The service supports various image formats like JPEG, PNG, and GIF, with a maximum file size of 600kB and a maximum dimension of 1000px on any side. It requires images in Base64 format and allows for additional instructions or comments to guide the annotation process.

Request example

Method: createTask
API endpoint: https://{{api_hostname}}/createTask

{
    "clientKey":"YOUR_API_KEY",
    "task": {
        "type":"BoundingBoxTask",
        "body":"/9j/4AAQSkZJRgABAQAAAQ..HIAAAAAAQwAABtbnRyUkdCIFhZ.wc5GOGSRF//Z",
        "comment":"draw a tight box around the green apple"
    }
}

Response example

{
    "errorId": 0,
    "status": "ready",
    "solution": {
        "bounding_boxes": [
            {
                "xMin": 310,
                "xMax": 385,
                "yMin": 231,
                "yMax": 308
            }
        ]
    },
    "cost": "0.0012",
    "ip": "1.2.3.4",
    "createTime": 1692863536,
    "endTime": 1692863556,
    "solveCount": 1
}

Bounding boxes are more than just simple rectangles drawn around objects. They are the building blocks of complex machine learning systems that are reshaping our world. By understanding and utilizing bounding boxes, developers and data scientists are pushing the boundaries of what's possible in AI and computer vision.