How to bypass Prosopo Captcha

Introduction

Prosopo Procaptcha is a modern, open-source protection system designed as a privacy-focused and decentralized alternative to reCAPTCHA. It uses a token-based approach: upon successful verification, the site receives a signed token that is submitted alongside the form to confirm the request originates from a real user.

Features of Procaptcha that make automation challenging:

• Domain binding via siteKey
• Tokens are valid for a limited time
• IP address may be validated during token verification

This guide covers how to automatically bypass Prosopo Procaptcha using the 2Captcha API — including how to find the required parameters on a page, create a task, and correctly inject the returned token.

How to Find Procaptcha Parameters on a Page

Only one key parameter is needed to solve the captcha — the siteKey.

1. Open the target page in your browser and launch Developer Tools (F12).
2. Go to the Elements tab and find the
   tag with the data-sitekey attribute — that value is the siteKey.
3. Alternatively, open the Network tab, reload the page, and look for requests to procaptcha.io or prosopo.io. The siteKey will be present in the request parameters.

Example of how the Procaptcha widget looks in page source:

<div
  class="procaptcha"
  data-sitekey="5EPQoMZEDc5LpN7gtxMMzYPTzA6UeWqL2stk1rso9gy4Ahqt"
></div>

API Parameters

The 2Captcha API supports two task types for Prosopo Procaptcha:

• ProsopoTaskProxyless — the service uses its own proxy pool
• ProsopoTask — the service uses your proxies

Required Parameters (both task types)

Proxy Parameters (ProsopoTask only)

Use ProsopoTask if the target site strictly validates the IP address during token verification.

JSON Request Examples

Create Task Request (Proxyless)

{
    "clientKey": "YOUR_API_KEY",
    "task": {
        "type": "ProsopoTaskProxyless",
        "websiteURL": "https://www.example.com/",
        "websiteKey": "5EPQoMZEDc5LpN7gtxMMzYPTzA6UeWqL2stk1rso9gy4Ahqt"
    }
}

Create Task Request (with your proxy)

{
    "clientKey": "YOUR_API_KEY",
    "task": {
        "type": "ProsopoTask",
        "websiteURL": "https://www.example.com/",
        "websiteKey": "5EPQoMZEDc5LpN7gtxMMzYPTzA6UeWqL2stk1rso9gy4Ahqt",
        "proxyType": "http",
        "proxyAddress": "1.2.3.4",
        "proxyPort": 8080,
        "proxyLogin": "user23",
        "proxyPassword": "p4$w0rd"
    }
}

Successful Response

The getTaskResult response returns the token in the solution.token field. This is the value you need to inject into the target site.

{
    "errorId": 0,
    "status": "ready",
    "solution": {
        "token": "0x00016c68747470733a2f2f70726f6e6f6465332e70726f736f706f2e696fc0354550516f4d5a454463354c704e376774784d4d7a5950547a4136..."
    },
    "cost": "0.00299",
    "ip": "1.2.3.4",
    "createTime": 1692863536,
    "endTime": 1692863556,
    "solveCount": 1
}

Step-by-Step Python Implementation

Step 1: Create a Task

import requests

API_KEY = "YOUR_API_KEY"

def create_prosopo_task(website_url, website_key):
    payload = {
        "clientKey": API_KEY,
        "task": {
            "type": "ProsopoTaskProxyless",
            "websiteURL": website_url,
            "websiteKey": website_key
        }
    }

    response = requests.post("https://api.2captcha.com/createTask", json=payload)
    result = response.json()

    if result.get("errorId") != 0:
        raise Exception(f"Task creation error: {result.get('errorDescription')}")

    return result["taskId"]

Step 2: Retrieve the Result

import time

def get_prosopo_result(task_id):
    while True:
        time.sleep(5)

        payload = {
            "clientKey": API_KEY,
            "taskId": task_id
        }

        response = requests.post("https://api.2captcha.com/getTaskResult", json=payload)
        result = response.json()

        if result.get("status") == "ready":
            return result["solution"]["token"]
        elif result.get("errorId") != 0:
            raise Exception(f"API error: {result.get('errorDescription')}")

Full Code Examples

Python (via the Official SDK)

Using the official SDK greatly simplifies the integration — the library handles polling the task status and returns the result automatically.

from twocaptcha import TwoCaptcha

solver = TwoCaptcha('YOUR_API_KEY')

try:
    result = solver.prosopo(
        sitekey='5EPQoMZEDc5LpN7gtxMMzYPTzA6UeWqL2stk1rso9gy4Ahqt',
        url='https://www.example.com/'
    )

    token = result['code']
    print(f"Token received: {token[:60]}...")

except Exception as e:
    print(f"Solving error: {e}")

Selenium Integration and Token Injection

Once you have the token, it must be submitted to the target site. Procaptcha typically expects the token in a hidden form field named procaptcha-response, or via a JavaScript callback.

from selenium import webdriver
from selenium.webdriver.common.by import By
from twocaptcha import TwoCaptcha
import time

driver = webdriver.Chrome()
driver.get("https://www.example.com/")
time.sleep(3)  # Wait for the page and captcha widget to fully load

# Extract siteKey directly from the widget attribute
site_key = driver.find_element(
    By.CSS_SELECTOR, ".procaptcha[data-sitekey]"
).get_attribute("data-sitekey")

# Solve the captcha via 2Captcha/2Captcha
solver = TwoCaptcha('YOUR_API_KEY')
result = solver.prosopo(sitekey=site_key, url=driver.current_url)
token = result['code']

# Inject the token into the hidden form field
driver.execute_script(f"""
    let input = document.querySelector('input[name="procaptcha-response"]');
    if (!input) {{
        input = document.createElement('input');
        input.type = 'hidden';
        input.name = 'procaptcha-response';
        document.querySelector('form').appendChild(input);
    }}
    input.value = '{token}';
""")

# Submit the form
driver.find_element(By.CSS_SELECTOR, "button[type='submit']").click()

Best Practices

1. Copy websiteKey Exactly

The siteKey is case-sensitive and must be copied verbatim from the data-sitekey attribute or network requests. Even a single extra character will cause the task to fail.

2. Inject the Token as Soon as Possible

Procaptcha tokens have a limited lifetime (typically 1–2 minutes). As soon as you receive the token from the API, inject it into the form and submit immediately — do not store it for later use.

3. Use ProsopoTask with Residential Proxies on Strict Sites

If the target site checks that the IP used to solve the captcha matches the IP used to submit the form, use ProsopoTask and pass your residential proxy credentials. Datacenter proxies may be blocked.

4. Always Use the Correct Page URL

The websiteURL parameter must exactly match the address of the page where the captcha is displayed. An incorrect URL may cause the token to fail server-side validation.

Reporting Solution Quality

If the token returned by the API was rejected by the target site, you can report it via the 2Captcha reporting system. This helps improve overall solution quality.

When to Send Reports

Send reportIncorrect if:

• The site rejected the token after injection
• The form was not accepted after submission with the token
• The captcha returned a server-side validation error

Send reportCorrect if:

• The token passed validation and the form was accepted successfully
• You want to confirm a high-quality result from a worker

Report Parameters

Report Submission Example

import requests

API_KEY = "YOUR_API_KEY"

def report_incorrect(task_id):
    """Report an incorrect Procaptcha solution"""
    response = requests.post(
        "https://api.2captcha.com/reportIncorrect",
        json={
            "clientKey": API_KEY,
            "taskId": task_id
        }
    )
    return response.json().get("errorId") == 0

def report_correct(task_id):
    """Confirm a correct Procaptcha solution"""
    response = requests.post(
        "https://api.2captcha.com/reportCorrect",
        json={
            "clientKey": API_KEY,
            "taskId": task_id
        }
    )
    return response.json().get("errorId") == 0

Key Notes on Reporting

1. Always save the taskId — you need it to send a report after verifying the token on the target site.
2. Report promptly — reports are only accepted within a certain time window after a task is completed.
3. Do not misuse reports — only send reportIncorrect if you are confident the issue is on the service side, not caused by an expired session or incorrect token injection.

Troubleshooting

Site Rejects the Token (Invalid Token)

Possible causes and fixes:

• Verify that websiteKey was copied exactly — no leading/trailing spaces or missing characters.
• Check whether the token has expired: inject it immediately after receiving it.
• Switch to ProsopoTask with a residential proxy if the site enforces IP consistency between solving and form submission.
• Make sure the token is being injected into the correct form field (procaptcha-response or a site-specific field name).

ERROR_CAPTCHA_UNSOLVABLE

Possible causes and fixes:

• Double-check the websiteKey and websiteURL values.
• Confirm the captcha widget actually loads at the given URL (the page is publicly accessible and does not require login to display the widget).
• Try passing a current browser User-Agent if the API supports it.

Captcha Widget Does Not Appear During Automation

Possible causes and fixes:

• Procaptcha may not load if the site detects automation signals (e.g., standard Selenium or Playwright without stealth mode). Use undetected-chromedriver or stealth plugins such as playwright-stealth.
• Wait for the page and widget to fully load before collecting parameters — use explicit waits (WebDriverWait) rather than fixed time.sleep calls.

Useful Links

• Prosopo Procaptcha API documentation: https://2captcha.com/api-docs/prosopo-procaptcha
• Procaptcha solver page: https://2captcha.com/p/procaptcha-solver
• Code examples on GitHub: https://github.com/2captcha
• Support center: https://2captcha.com/support/tickets/new
• How to submit reports: https://2captcha.com/h/how-to-submit-reports

Conclusion

Bypassing Prosopo Procaptcha via 2Captcha follows a straightforward token-based workflow: locate the siteKey, submit a task to the API, receive the token, and inject it into the form.

Key takeaways:

1. The only required parameter is websiteKey (siteKey). Copy it exactly from the data-sitekey attribute of the widget on the page.
2. Inject the token immediately after receiving it — it has a limited lifetime.
3. If the site validates the IP during token verification, use ProsopoTask with residential proxies.
4. Always save the taskId so you can submit quality reports after verifying the solution.
5. When using Selenium or Playwright, enable stealth mode so the Procaptcha widget loads correctly.

By following these recommendations, you can reliably automate interactions with sites protected by Prosopo Procaptcha.