How to bypass reCAPTCHA v3 on Waze

Introduction

Waze is a popular navigation and traffic tracking application. Its interactive map (Live Map) uses reCAPTCHA v3 to protect API endpoints and prevent automated requests. Unlike previous versions, reCAPTCHA v3 works invisibly to the user and evaluates behavior based on a score from 0.0 to 1.0.

In this guide, we will break down how to get the necessary parameters, solve the captcha via the 2Captcha API, and correctly integrate the token into your script.

Task parameters

To bypass reCAPTCHA v3 on Waze, the RecaptchaV3TaskProxyless task type is used.

{
    "clientKey": "YOUR_API_KEY",
    "task": {
        "type": "RecaptchaV3TaskProxyless",
        "websiteURL": "https://www.waze.com/ru/live-map",
        "websiteKey": "6Lf4WdUqAAAAAEUYUvzyLYIkO3PoFAqi8ZHGiDLW",
        "pageAction": "api",
        "minScore": 0.3,
        "apiDomain": "www.recaptcha.net",
        "isEnterprise": true
    }
}

How to find parameters

websiteURL

This is the full address of the page where the verification is initiated. For Waze, this can be the main map page (https://www.waze.com/live-map) or its localized version (https://www.waze.com/ru/live-map).

websiteKey (SiteKey)

1. Open the map page and press F12 (DevTools).
2. Go to the Elements tab and press Ctrl+F to search.
3. Type 6Lf4 or recaptcha and copy the value of the data-sitekey attribute.
4. Alternatively, on the Network tab, you can find a request to google.com/recaptcha or recaptcha.net and look at the k parameter.

pageAction

This parameter specifies which exact action on the site triggers the captcha.

1. On the Sources tab or in the DevTools console, find the grecaptcha.execute call.
2. The second argument of this call usually contains an object with the action field. For Waze, when loading the map, this is often the value api or live_map.

apiDomain

Check which domain the captcha script is loaded from. If the script URL specifies recaptcha.net (for example, https://www.recaptcha.net/recaptcha/enterprise.js), pass www.recaptcha.net. If the standard Google domain is used, specify www.google.com.

isEnterprise

Check the URL of the loaded script. If it contains the word enterprise (for example, recaptcha/enterprise.js), it means the corporate version is used, and this parameter must be true.

reCAPTCHA v3 specifics and Waze features

Solving reCAPTCHA v3 is a complex task, as it imposes strict requirements on the score value. Success depends on a combination of factors: correct parameters, browser digital fingerprints, and session behavior.

However, as practice has shown, our tokens with a high score successfully pass the captcha on this site. The main thing is to use the correct parameters (especially pageAction and apiDomain).

Why minScore=0.3 and not 0.9

reCAPTCHA v3 returns a score from 0.0 to 1.0, where:

• 0.9-1.0 — very likely a human
• 0.5-0.8 — possibly a human
• 0.0-0.4 — very likely a bot

Many developers mistakenly set minScore=0.9, expecting a "perfect" token. But this leads to problems:

1. Long wait times — it is harder for the service to get a token with such a high score.
2. Blocks — if the site expects a score of 0.7, and you pass a token with a score of 0.95, it might look suspicious.
3. Extra costs — the service might not find a solution with such a high score and return an error.

For Waze, the optimal minScore is 0.3 because:

• The site accepts tokens with a relatively low score.
• A solution is found faster.
• There is less chance of being blocked due to "too perfect" behavior.

If the site rejects tokens with a score of 0.3, try increasing it to 0.5 or 0.7.

How exactly Waze expects the token

Waze uses reCAPTCHA v3 Enterprise to protect its API endpoints. The token is usually passed in the body of a POST request as a recaptcha_token or g-recaptcha-response parameter.

Example of a request to the Waze API:

import requests

token = "YOUR_RECAPTCHA_TOKEN"

headers = {
    'Content-Type': 'application/json',
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
}

data = {
    'recaptcha_token': token,
    # other request parameters
}

response = requests.post(
    'https://www.waze.com/row-rtserver/web/TGeoSearch',
    headers=headers,
    json=data
)

print(response.json())

If you are using Playwright/Selenium, the token can be passed by intercepting requests (as shown in the example below) or by executing JavaScript:

await page.evaluate(f"""
    window.recaptchaToken = '{token}';
""")

Code examples

Python + requests (Getting the token)

If you just need to get the token to subsequently send it to the Waze backend via API:

import sys
import os
sys.path.append(os.path.dirname(os.path.dirname(os.path.realpath(__file__))))

from twocaptcha import TwoCaptcha

api_key = os.getenv('APIKEY_2CAPTCHA', 'YOUR_API_KEY')
solver = TwoCaptcha(api_key)

try:
    result = solver.recaptcha(
        sitekey='6Lf4WdUqAAAAAEUYUvzyLYIkO3PoFAqi8ZHGiDLW',
        url='https://www.waze.com/ru/live-map',
        version='v3',
        action='api',
        min_score=0.3,
        domain='www.recaptcha.net',
        enterprise=1
    )
    print(f"Token successfully received: {result['code']}")
    
except Exception as e:
    print(f"An error occurred: {e}")

Python + Playwright (Browser automation)

When automating a browser, the reCAPTCHA v3 token is usually passed directly in the body of a POST request to the site's API or written to a header.

import asyncio
from playwright.async_api import async_playwright
from twocaptcha import TwoCaptcha

API_KEY = 'YOUR_API_KEY'
SITE_KEY = '6Lf4WdUqAAAAAEUYUvzyLYIkO3PoFAqi8ZHGiDLW'
PAGE_URL = 'https://www.waze.com/ru/live-map'

async def solve_captcha():
    solver = TwoCaptcha(API_KEY)
    
    try:
        result = solver.recaptcha(
            sitekey=SITE_KEY,
            url=PAGE_URL,
            version='v3',
            action='api',
            min_score=0.3,
            domain='www.recaptcha.net',
            is_enterprise=True
        )
        token = result['code']
        print(f"Captcha solved! Token: {token}")
        
        async with async_playwright() as p:
            browser = await p.chromium.launch()
            context = await browser.new_context()
            page = await context.new_page()
            
            await page.goto(PAGE_URL)
            
            async def handle_route(route):
                request = route.request
                headers = request.headers
                headers['g-recaptcha-response'] = token
                await route.continue_(headers=headers)
            
            await page.route('**/api/**', handle_route)
            
            await page.reload()
            
            await asyncio.sleep(5)
            await browser.close()
            
    except Exception as e:
        print(f"Error: {e}")

asyncio.run(solve_captcha())

Solution accuracy reports

For reCAPTCHA v3, sending reports is critically important. If the site rejected the token, be sure to report it via the reportIncorrect method. This helps the service analyze the reasons for the low score and refunds your funds. If the token successfully passed the verification, send reportCorrect — this consolidates positive statistics and helps maintain a high level of solution quality.

You can submit a report via the API:

import requests

API_KEY = "YOUR_API_KEY"
TASK_ID = "123456789"

# Report for an incorrect solution
requests.post(
    "https://api.2captcha.com/reportIncorrect",
    json={"clientKey": API_KEY, "taskId": TASK_ID}
)

# Report for a correct solution
requests.post(
    "https://api.2captcha.com/reportCorrect",
    json={"clientKey": API_KEY, "taskId": TASK_ID}
)

Detailed guide on submitting reports with examples for different languages: https://2captcha.com/h/how-to-submit-reports

Common errors and solutions

Useful links

• Sandbox for API testing: https://2captcha.com/setting#sandbox
• reCAPTCHA v3 documentation: https://2captcha.com/api-docs/recaptcha-v3
• Detailed guide on submitting reports: https://2captcha.com/h/how-to-submit-reports
• Library for Python: https://github.com/2captcha/2captcha-python