As part of my scientific and research interests, I decided to experiment with bypassing complex types of CAPTCHAs. Well, by “experiment” I mean testing the functionality and verifying that my electronic colleague can write code on my behalf. Yes, there was a lot of extra stuff—follow ethical norms, blah blah blah… But the simple fact remains: dude, I’m doing this solely as part of research, and everyone agreed.

I turned my attention to the Cloudflare Turnstile CAPTCHA because I hadn’t encountered this specific type before, and I suggest we proceed step by step. First, let’s explain what Cloudflare Turnstile is for anyone who isn’t in the loop:

What is Cloudflare Turnstile CAPTCHA and Why Can Bypass Cloudflare Turnstile Be a Real Headache?

Cloudflare Turnstile is a CAPTCHA solution developed by Cloudflare designed to protect websites from automated access (bots) without creating unnecessary obstacles for users. The main idea is to provide a high level of security with minimal interference in the user experience. In some cases, the user may not even be required to take any additional actions—the verification can occur in the background.

But not in my case, as both types of Cloudflare Turnstile CAPTCHAs I bypassed were visibly rendered.

Cloudflare Turnstile CAPTCHA comes in a simpler version—reminiscent of reCAPTCHA—and a more complex variant: Challenge CAPTCHA is an advanced version that is employed when basic checks don’t conclusively determine whether the visitor is human. This system integrates extra verification steps to enhance security without immediately burdening all users with complex challenges.

For a basic understanding, here’s the deal: to solve a simple CAPTCHA, everything needed for its solution can be found in the HTML code of the page—namely, the sitekey (you open the page in developer mode and use Ctrl + F to search for “sitekey”). However, with the second variant, that method won’t work because all necessary parameters are generated in JavaScript and cannot simply be extracted from the page’s source code; you need to intercept the data (and that’s a bit more complicated).

I took the simpler route—I had two URLs, one with a simple Cloudflare Turnstile CAPTCHA and the other with a complex one:
https://privacy.deepsync.com/ – here, it’s simple
https://crash.chicagopolice.org/ – here, it’s complex

The Simple Cloudflare Turnstile CAPTCHA or Bypassing Cloudflare on Python Without “Mom, Dad, and Grandma’s Advice”

First things first: let’s tackle the simple CAPTCHA. I searched online for “Cloudflare Turnstile bypass CAPTCHA” and once again encountered a popular captcha solve service. Their API was described in detail, but here’s the catch—I didn’t feel like writing code manually, so I delegated the task to my neural network colleague, who, through trial and error, assembled the following solution:

import argparse
import requests
import time




from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait, Select
from selenium.webdriver.support import expected_conditions as EC




def get_turnstile_solution(api_key, site_key, page_url):
    """
    Sends a task to solve the Turnstile CAPTCHA via 2captcha and polls for the result.
    Returns the solution token (str) or None if something goes wrong.
    """
    in_url = 'http://2captcha.com/in.php'
    payload = {
        'key': api_key,
        'method': 'turnstile',
        'sitekey': site_key,
        'pageurl': page_url,
        'json': 1
    }
   
    try:
        response = requests.post(in_url, data=payload)
        result = response.json()
    except Exception as e:
        print("Error while sending request to 2captcha:", e)
        return None




    if result.get('status') != 1:
        print("Error submitting task:", result.get('request'))
        return None




    captcha_id = result.get('request')
    print("CAPTCHA solving task submitted, ID:", captcha_id)




    # Poll the result from 2captcha every 5 seconds
    res_url = 'http://2captcha.com/res.php'
    params = {
        'key': api_key,
        'action': 'get',
        'id': captcha_id,
        'json': 1
    }




    while True:
        time.sleep(5)
        try:
            res_response = requests.get(res_url, params=params)
            res_result = res_response.json()
        except Exception as e:
            print("Error while retrieving result:", e)
            return None




        if res_result.get('status') == 1:
            solution_token = res_result.get('request')
            print("CAPTCHA solution received:", solution_token)
            return solution_token
        elif res_result.get('request') == "CAPCHA_NOT_READY":
            print("Solution not ready yet, retrying...")
            continue
        else:
            print("Error retrieving solution:", res_result.get('request'))
            return None




def main():
    parser = argparse.ArgumentParser(
        description='Demonstration of form auto-fill and solving Turnstile CAPTCHA via 2captcha.'
    )
    parser.add_argument('api_key', type=str, nargs='?', help='Your 2captcha API key')
    parser.add_argument('url', type=str, nargs='?', help='URL of the page with the form and Turnstile CAPTCHA')
    args = parser.parse_args()




    if not args.api_key:
        args.api_key = input("Enter your 2captcha API key: ")
    if not args.url:
        args.url = input("Enter the URL of the page with the CAPTCHA: ")




    # 1) Launch Selenium in visual mode (without headless) so you can observe the process
    chrome_options = Options()
    driver = webdriver.Chrome(options=chrome_options)
    driver.get(args.url)




    wait = WebDriverWait(driver, 30)




    try:
        # 2) Wait for the element with the class .cf-turnstile to appear
        turnstile_div = wait.until(
            EC.presence_of_element_located((By.CSS_SELECTOR, ".cf-turnstile"))
        )
    except Exception as e:
        print("Error: element with class .cf-turnstile not found:", e)
        driver.quit()
        return




    # Extract the sitekey from the data-sitekey attribute
    site_key = turnstile_div.get_attribute("data-sitekey")
    print("Sitekey found:", site_key)




    # ----- Step 1: Automatically fill in the form fields -----
    try:
        # Example: select "A deceased individual"
        select_request_type = Select(driver.find_element(By.ID, "request_type"))
        select_request_type.select_by_value("deceased")  
       
        # First name, last name
        driver.find_element(By.ID, "first_name").send_keys("John")
        driver.find_element(By.ID, "last_name").send_keys("Doe")
       
        # Email, phone
        driver.find_element(By.ID, "email").send_keys("test@example.com")
        driver.find_element(By.ID, "phone").send_keys("1234567890")
       
        # Address
        driver.find_element(By.ID, "who_address").send_keys("123 Test Street")
        driver.find_element(By.ID, "who_address2").send_keys("Apt 4")
        driver.find_element(By.ID, "who_city").send_keys("Test City")
       
        select_state = Select(driver.find_element(By.ID, "who_state"))
        select_state.select_by_value("CA")  # California
       
        driver.find_element(By.ID, "who_zip").send_keys("90001")
       
        # Check the "Requests" checkboxes
        driver.find_element(By.ID, "request_type_1").click()  # Do not sell/share my personal information
        driver.find_element(By.ID, "request_type_2").click()  # Do not use my personal data for targeted advertising
        # ... you can select the others if necessary
       
        print("Form fields have been filled with test data.")
    except Exception as e:
        print("Error auto-filling form fields:", e)
        driver.quit()
        return




    # ----- Step 2: Solve the CAPTCHA via 2captcha -----
    token = get_turnstile_solution(args.api_key, site_key, args.url)
    if not token:
        print("Failed to obtain CAPTCHA solution.")
        driver.quit()
        return




    # ----- Step 3: Insert the solution into the hidden field and call the callback -----
    try:
        # Locate the hidden field that Turnstile uses to store the response
        input_field = wait.until(
            EC.presence_of_element_located(
                (By.CSS_SELECTOR, 'input#cf-chl-widget-yi26c_response, input[name="cf-turnstile-response"]')
            )
        )
        # Insert the obtained token
        driver.execute_script("arguments[0].value = arguments[1];", input_field, token)
        print("CAPTCHA solution token inserted into the hidden field.")




        # Generate the 'change' event
        driver.execute_script("""
            var event = new Event('change', { bubbles: true });
            arguments[0].dispatchEvent(event);
        """, input_field)




        # If the site uses a callback function for Turnstile, attempt to call it
        driver.execute_script("""
            if (window.tsCallback) {
                window.tsCallback(arguments[0]);
            }
        """, token)
        print("Callback invoked (if it was defined).")




    except Exception as e:
        print("Error inserting CAPTCHA token:", e)
        driver.quit()
        return




    # ----- Step 4: Submit the form to proceed to the next stage -----
    try:
        submit_button = wait.until(
            EC.element_to_be_clickable((By.ID, "submit_button"))
        )
        submit_button.click()
        print("Click on the 'Submit' button executed.")




        # Wait for the URL to change after submission
        wait.until(EC.url_changes(args.url))
        print("Transition to the next stage detected. Current URL:", driver.current_url)




    except Exception as e:
        print("Failed to click 'Submit' or wait for the next stage:", e)




    print("Automation completed. The browser window remains open for verification.")
    input("Press Enter to close the browser...")
    driver.quit()




if __name__ == '__main__':
    main()

The best part about all this is that the script works without any additional files; you simply save everything in one file, install the necessary dependencies, and the script runs. For the script, you need to install Selenium and the requests library, which you can do with the following simple console command:

pip install selenium requests

There is a nuance—this code is adapted for a specific website (mentioned above) and not only bypasses the CAPTCHA but also automatically inputs data on the site.

How Script for Bypass Cloudflare Turnstile Works – A Detailed Breakdown

Using the argparse module, the script accepts a 2captcha API key and the URL of the page containing the CAPTCHA. It prompts you to enter them manually in the console (nothing complicated).

Then a browser is launched (I did not use headless mode so I could record a video of how everything works), and using WebDriverWait, the script waits for the element with the class .cf-turnstile—which is responsible for displaying the CAPTCHA—to appear on the page. From this element, it extracts the data-sitekey attribute—the unique key needed to interact with the CAPTCHA.

Simultaneously, form fields are being filled (this part isn’t of much interest—it was implemented simply so that the script would run to completion).

After obtaining the necessary parameter, it is sent to the 2captcha server where the CAPTCHA is solved, and the solution (token) is sent back to the script so it can be inserted.

The script then looks for a hidden field on the page into which the token should be inserted (using CSS selectors targeting fields with the name cf-turnstile-response or a specific ID).

Using execute_script, the token is inserted into the located field, after which a change event is created and dispatched, allowing the page to respond to the insertion of the solution. If a callback function is defined on the page (for example, window.tsCallback), it is invoked to notify the page’s script that the CAPTCHA has been solved. As soon as the CAPTCHA submission button becomes clickable, the script clicks it. And that’s it—below is a video demonstrating how it works in reality:

For variety, and so as not to rely solely on 2captcha, I modified the script to work with SolveCaptcha—luckily, the method of solving doesn’t differ much. Here is an analogous script, but with SolveCaptcha as the third-party service:

import argparse
import requests
import time


from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait, Select
from selenium.webdriver.support import expected_conditions as EC


def get_turnstile_solution(api_key, site_key, page_url):
    """
    Sends a task to solve the Turnstile CAPTCHA via solvecaptcha and polls for the result.
    Returns the solution token (str) or None if something goes wrong.
    """
    # URL to send the task to solvecaptcha
    in_url = 'https://api.solvecaptcha.com/in.php'
    payload = {
        'key': api_key,
        'method': 'turnstile',
        'sitekey': site_key,
        'pageurl': page_url,
        'json': 1
    }
   
    try:
        response = requests.post(in_url, data=payload)
        result = response.json()
    except Exception as e:
        print("Error while sending request to solvecaptcha:", e)
        return None


    if result.get('status') != 1:
        print("Error submitting task:", result.get('request'))
        return None


    captcha_id = result.get('request')
    print("CAPTCHA solving task submitted, ID:", captcha_id)


    # Poll the result from solvecaptcha every 5 seconds
    res_url = 'https://api.solvecaptcha.com/res.php'
    params = {
        'key': api_key,
        'action': 'get',
        'id': captcha_id,
        'json': 1
    }


    while True:
        time.sleep(5)
        try:
            res_response = requests.get(res_url, params=params)
            res_result = res_response.json()
        except Exception as e:
            print("Error while retrieving result:", e)
            return None


        if res_result.get('status') == 1:
            solution_token = res_result.get('request')
            print("CAPTCHA solution received:", solution_token)
            return solution_token
        elif res_result.get('request') == "CAPCHA_NOT_READY":
            print("Solution not ready yet, retrying...")
            continue
        else:
            print("Error retrieving solution:", res_result.get('request'))
            return None


def main():
    parser = argparse.ArgumentParser(
        description='Demonstration of form auto-fill and solving Turnstile CAPTCHA via solvecaptcha.'
    )
    parser.add_argument('api_key', type=str, nargs='?', help='Your solvecaptcha API key')
    parser.add_argument('url', type=str, nargs='?', help='URL of the page with the form and Turnstile CAPTCHA')
    args = parser.parse_args()


    if not args.api_key:
        args.api_key = input("Enter your solvecaptcha API key: ")
    if not args.url:
        args.url = input("Enter the URL of the page with the CAPTCHA: ")


    # 1) Launch Selenium in visual mode (without headless) so you can observe the process
    chrome_options = Options()
    driver = webdriver.Chrome(options=chrome_options)
    driver.get(args.url)


    wait = WebDriverWait(driver, 30)


    try:
        # 2) Wait for the element with the class .cf-turnstile to appear
        turnstile_div = wait.until(
            EC.presence_of_element_located((By.CSS_SELECTOR, ".cf-turnstile"))
        )
    except Exception as e:
        print("Error: element with class .cf-turnstile not found:", e)
        driver.quit()
        return


    # Extract the sitekey from the data-sitekey attribute
    site_key = turnstile_div.get_attribute("data-sitekey")
    print("Sitekey found:", site_key)


    # ----- Step 1: Automatically fill in the form fields -----
    try:
        # Example: select "A deceased individual"
        select_request_type = Select(driver.find_element(By.ID, "request_type"))
        select_request_type.select_by_value("deceased")  
       
        # First name, last name
        driver.find_element(By.ID, "first_name").send_keys("John")
        driver.find_element(By.ID, "last_name").send_keys("Doe")
       
        # Email, phone
        driver.find_element(By.ID, "email").send_keys("test@example.com")
        driver.find_element(By.ID, "phone").send_keys("1234567890")
       
        # Address
        driver.find_element(By.ID, "who_address").send_keys("123 Test Street")
        driver.find_element(By.ID, "who_address2").send_keys("Apt 4")
        driver.find_element(By.ID, "who_city").send_keys("Test City")
       
        select_state = Select(driver.find_element(By.ID, "who_state"))
        select_state.select_by_value("CA")  # California
       
        driver.find_element(By.ID, "who_zip").send_keys("90001")
       
        # Check the "Requests" checkboxes
        driver.find_element(By.ID, "request_type_1").click()  # Do not sell/share my personal information
        driver.find_element(By.ID, "request_type_2").click()  # Do not use my personal data for targeted advertising
        # ... you can select the others if necessary
       
        print("Form fields have been filled with test data.")
    except Exception as e:
        print("Error auto-filling form fields:", e)
        driver.quit()
        return


    # ----- Step 2: Solve the CAPTCHA via solvecaptcha -----
    token = get_turnstile_solution(args.api_key, site_key, args.url)
    if not token:
        print("Failed to obtain CAPTCHA solution.")
        driver.quit()
        return


    # ----- Step 3: Insert the solution into the hidden field and call the callback -----
    try:
        # Locate the hidden field that Turnstile uses to store the response
        input_field = wait.until(
            EC.presence_of_element_located(
                (By.CSS_SELECTOR, 'input#cf-chl-widget-yi26c_response, input[name="cf-turnstile-response"]')
            )
        )
        # Insert the obtained token
        driver.execute_script("arguments[0].value = arguments[1];", input_field, token)
        print("CAPTCHA solution token inserted into the hidden field.")


        # Generate the 'change' event
        driver.execute_script("""
            var event = new Event('change', { bubbles: true });
            arguments[0].dispatchEvent(event);
        """, input_field)


        # If the site uses a callback function for Turnstile, attempt to call it
        driver.execute_script("""
            if (window.tsCallback) {
                window.tsCallback(arguments[0]);
            }
        """, token)
        print("Callback invoked (if it was defined).")


    except Exception as e:
        print("Error inserting CAPTCHA token:", e)
        driver.quit()
        return


    # ----- Step 4: Submit the form to proceed to the next stage -----
    try:
        submit_button = wait.until(
            EC.element_to_be_clickable((By.ID, "submit_button"))
        )
        submit_button.click()
        print("Click on the 'Submit' button executed.")


        # Wait for the URL to change after submission
        wait.until(EC.url_changes(args.url))
        print("Transition to the next stage detected. Current URL:", driver.current_url)


    except Exception as e:
        print("Failed to click 'Submit' or wait for the next stage:", e)


    print("Automation completed. The browser window remains open for verification.")
    input("Press Enter to close the browser...")
    driver.quit()


if __name__ == '__main__':
    main()

The principle of operation is exactly the same—only the API key must be replaced with the SolveCaptcha API key.

The Complex Type of Cloudflare Turnstile CAPTCHA – When Bypassing Cloudflare Truly Becomes a Headache (And What’s with node.js?)

With the second type of Cloudflare Turnstile CAPTCHA, I certainly had to struggle, as my steadfast “iron colleague” (my computer) couldn’t deliver a working solution in Python; things kept breaking, data wasn’t intercepted, and something was always missing.

I had to resort to old-fashioned methods and search for information online once again.

I Googled this repository: https://github.com/2captcha/cloudflare-demo

What are you saying, kid? Yes, darn it—the same service appears again! But I’m not to blame that they’re everywhere in this field!

I found the repository, and it turned out to be functional—you just need to change this line:

page.goto('https://2captcha.com/demo/cloudflare-turnstile-challenge')

Replace the URL with your own and insert your API key, and everything works. However, the catch was that I wanted a Python solution, and this one is in node.js.

The Situation

I uploaded all the files into the boundless repository of my reliable “iron colleague” and asked him to copy the solution and convert it to Python.

At first, we tried the simple approach using Puppeteer (as they say – “It’s liquid stool and we’re not going to show it”), but the solution didn’t work… not on the first try, not even after five attempts—nothing.

Then we changed our approach and modernized the script to work with Playwright, and that’s when the machine finally started, albeit not on the first try.

Here is the script:

import asyncio
import json
import re
import os
import time
import requests
from playwright.async_api import async_playwright




# Set the API key directly in the file
API_KEY = "Ваш ключ АПИ"




async def normalize_user_agent(playwright):
    """
    Retrieves the user agent using a temporary headless browser and normalizes it.
    """
    browser = await playwright.chromium.launch(headless=True)
    context = await browser.new_context()
    page = await context.new_page()
    user_agent = await page.evaluate("() => navigator.userAgent")
    normalized = re.sub(r'Headless', '', user_agent)
    normalized = re.sub(r'Chromium', 'Chrome', normalized)
    await browser.close()
    return normalized.strip()




def solve_turnstile(params, api_key):
    """
    Sends the CAPTCHA parameters to 2Captcha and polls for the result until solved.
    """
    base_url = 'http://2captcha.com'
    in_params = {
        'key': api_key,
        'method': 'turnstile',
        'sitekey': params.get('sitekey'),
        'pageurl': params.get('pageurl'),
        'data': params.get('data'),
        'action': params.get('action'),
        'userAgent': params.get('userAgent'),
        'json': 1
    }
    if 'pagedata' in params:
        in_params['pagedata'] = params.get('pagedata')
   
    print("Sending CAPTCHA for solving...")
    r = requests.get(f"{base_url}/in.php", params=in_params)
    res_json = r.json()
    if res_json.get('status') != 1:
        raise Exception("Error submitting CAPTCHA: " + res_json.get('request'))
    captcha_id = res_json.get('request')
    print(f"Task submitted, ID: {captcha_id}")
   
    # Initial delay before polling
    time.sleep(10)
    while True:
        r = requests.get(f"{base_url}/res.php", params={
            'key': api_key,
            'action': 'get',
            'id': captcha_id,
            'json': 1
        })
        res_json = r.json()
        if res_json.get('status') == 1:
            token = res_json.get('request')
            print(f"CAPTCHA solved, token: {token}")
            return token
        elif res_json.get('request') == 'CAPCHA_NOT_READY':
            print("Solution not ready, waiting 5 seconds...")
            time.sleep(5)
        else:
            raise Exception("Error solving CAPTCHA: " + res_json.get('request'))




async def handle_console(msg, page, captcha_future):
    """
    Console message handler. Upon receiving a string with the prefix "intercepted-params:",
    parses the JSON, sends the parameters to 2Captcha, and returns the obtained token.
    """
    text = msg.text
    if "intercepted-params:" in text:
        json_str = text.split("intercepted-params:", 1)[1]
        try:
            params = json.loads(json_str)
        except json.JSONDecodeError:
            print("Error parsing JSON from intercepted-params")
            return
        print("Intercepted parameters:", params)
        api_key = API_KEY
        if not api_key:
            print("APIKEY environment variable is not set.")
            await page.context.browser.close()
            return
        try:
            token = solve_turnstile(params, api_key)
            # Send the token back to the page via callback call
            await page.evaluate("""(token) => {
                window.cfCallback(token);
            }""", token)
            if not captcha_future.done():
                captcha_future.set_result(token)
        except Exception as e:
            print("Error solving CAPTCHA:", e)
            if not captcha_future.done():
                captcha_future.set_exception(e)




async def main():
    async with async_playwright() as p:
        # Retrieve normalized user agent
        user_agent = await normalize_user_agent(p)
        print("Normalized user agent:", user_agent)
       
        # Launch browser with visible window
        browser = await p.chromium.launch(headless=False)
        context = await browser.new_context(user_agent=user_agent)
       
        # Read the contents of the inject.js file
        with open("inject.js", "r", encoding="utf-8") as f:
            inject_script = f.read()
        # Add the script for injection into every page
        await context.add_init_script(script=inject_script)
       
        page = await context.new_page()
       
        # Create a future to wait for the CAPTCHA solution result
        captcha_future = asyncio.Future()
       
        # Register console message handler
        page.on("console", lambda msg: asyncio.create_task(handle_console(msg, page, captcha_future)))
       
        # Navigate to the target page
        await page.goto("https://crash.chicagopolice.org/")
       
        try:
            token = await asyncio.wait_for(captcha_future, timeout=120)
            print("CAPTCHA token received:", token)
        except asyncio.TimeoutError:
            print("CAPTCHA wait time expired")
        await browser.close()




if __name__ == "__main__":
    asyncio.run(main())

The script works in tandem with the following injection (in English, that’s exactly what it’s called, and its functions are identical):

console.log('inject.js loaded');
console.clear = () => console.log('Console was cleared');
const i = setInterval(() => {
    if (window.turnstile) {
        console.log('window.turnstile detected');
        clearInterval(i);
        const originalRender = window.turnstile.render;
        window.turnstile.render = (a, b) => {
            console.log('Overriding window.turnstile.render');
            let params = {
                sitekey: b.sitekey,
                pageurl: window.location.href,
                data: b.cData,
                pagedata: b.chlPageData,
                action: b.action,
                userAgent: navigator.userAgent,
                json: 1
            };
            console.log('intercepted-params:' + JSON.stringify(params));
            window.cfCallback = b.callback;
            // If you need to call the original function, uncomment the following line:
            // return originalRender ? originalRender(a, b) : null;
            return;
        };
    }
}, 50);

This injection is embedded into every page via the context.add_init_script method. Its purpose is to intercept the call to the window.turnstile.render method, which is originally responsible for displaying and processing the CAPTCHA.

The script checks every 50 milliseconds to see if the window.turnstile object has appeared on the page. Then it constructs an object named params containing:

sitekey: the site key, passed via parameter b.
pageurl: the current URL of the page.
data: additional data (from b.cData).
pagedata: page data (from b.chlPageData).
action: the action that needs to be performed.
userAgent: the browser’s User Agent string.
json: a flag indicating a JSON request.

These parameters are then sent via our main script to the captcha bypass service, and the same magic happens as with the simple captcha—everything is solved, sent back, and inserted.

Similarly, I modified the intermediary script for SolveCaptcha—here is the script with the different service:


import asyncio
import json
import re
import os
import time
import requests
from playwright.async_api import async_playwright




# Set the API key directly in the file
API_KEY = "Your API key"




async def normalize_user_agent(playwright):
    """
    Retrieves the user agent using a temporary headless browser and normalizes it.
    """
    browser = await playwright.chromium.launch(headless=True)
    context = await browser.new_context()
    page = await context.new_page()
    user_agent = await page.evaluate("() => navigator.userAgent")
    normalized = re.sub(r'Headless', '', user_agent)
    normalized = re.sub(r'Chromium', 'Chrome', normalized)
    await browser.close()
    return normalized.strip()




def solve_turnstile(params, api_key):
    """
    Sends the CAPTCHA parameters to solvecaptcha and polls for the result until solved.
    """
    base_url = 'https://api.solvecaptcha.com'
    in_params = {
        'key': api_key,
        'method': 'turnstile',
        'sitekey': params.get('sitekey'),
        'pageurl': params.get('pageurl'),
        'data': params.get('data'),
        'action': params.get('action'),
        'userAgent': params.get('userAgent'),
        'json': 1
    }
    if 'pagedata' in params:
        in_params['pagedata'] = params.get('pagedata')
   
    print("Sending CAPTCHA for solving via solvecaptcha...")
    r = requests.get(f"{base_url}/in.php", params=in_params)
    res_json = r.json()
    if res_json.get('status') != 1:
        raise Exception("Error submitting CAPTCHA: " + res_json.get('request'))
    captcha_id = res_json.get('request')
    print(f"Task submitted, ID: {captcha_id}")
   
    # Initial delay before polling
    time.sleep(10)
    while True:
        r = requests.get(f"{base_url}/res.php", params={
            'key': api_key,
            'action': 'get',
            'id': captcha_id,
            'json': 1
        })
        res_json = r.json()
        if res_json.get('status') == 1:
            token = res_json.get('request')
            print(f"CAPTCHA solved, token: {token}")
            return token
        elif res_json.get('request') == 'CAPCHA_NOT_READY':
            print("Solution not ready, waiting 5 seconds...")
            time.sleep(5)
        else:
            raise Exception("Error solving CAPTCHA: " + res_json.get('request'))




async def handle_console(msg, page, captcha_future):
    """
    Console message handler. Upon receiving a string with the prefix "intercepted-params:",
    parses the JSON, sends the parameters to solvecaptcha, and returns the obtained token.
    """
    text = msg.text
    if "intercepted-params:" in text:
        json_str = text.split("intercepted-params:", 1)[1]
        try:
            params = json.loads(json_str)
        except json.JSONDecodeError:
            print("Error parsing JSON from intercepted-params")
            return
        print("Intercepted parameters:", params)
        api_key = API_KEY
        if not api_key:
            print("API key environment variable is not set.")
            await page.context.browser.close()
            return
        try:
            token = solve_turnstile(params, api_key)
            # Send the token back to the page via callback call
            await page.evaluate("""(token) => {
                window.cfCallback(token);
            }""", token)
            if not captcha_future.done():
                captcha_future.set_result(token)
        except Exception as e:
            print("Error solving CAPTCHA:", e)
            if not captcha_future.done():
                captcha_future.set_exception(e)




async def main():
    async with async_playwright() as p:
        # Retrieve normalized user agent
        user_agent = await normalize_user_agent(p)
        print("Normalized user agent:", user_agent)
       
        # Launch browser with visible window
        browser = await p.chromium.launch(headless=False)
        context = await browser.new_context(user_agent=user_agent)
       
        # Read the contents of the inject.js file
        with open("inject.js", "r", encoding="utf-8") as f:
            inject_script = f.read()
        # Add the injection script to every page
        await context.add_init_script(script=inject_script)
       
        page = await context.new_page()
       
        # Create a future to wait for the CAPTCHA solution result
        captcha_future = asyncio.Future()
       
        # Register console message handler
        page.on("console", lambda msg: asyncio.create_task(handle_console(msg, page, captcha_future)))
       
        # Navigate to the target page
        await page.goto("https://crash.chicagopolice.org/")
       
        try:
            token = await asyncio.wait_for(captcha_future, timeout=120)
            print("CAPTCHA token received:", token)
        except asyncio.TimeoutError:
            print("CAPTCHA wait time expired")
        await browser.close()

if __name__ == "__main__":
    asyncio.run(main())

It works just the same—don’t forget to insert your API key.

Thus, in our era, solving simple problems has become something extraordinary. With the right approach, we can stop burdening already harried developers on technical forums with basic questions. Of course, forum owners might be a bit saddened, as these simple questions generate tons of content that attracts other users—and you know how that goes.

How to Bypass Cloudflare Turnstile CAPTCHA – or Bypassing Cloudflare at Varying Levels of Difficulty