How to solve FunCaptcha on AMD DevCloud

Introduction

AMD DevCloud is a developer platform providing access to computing resources and AMD hardware. To protect registration and resource access processes, the site uses FunCaptcha (Arkose Labs). This is an interactive captcha that requires completing image-based tasks.

In this guide, we will break down how to get the necessary parameters, solve FunCaptcha via the 2Captcha API, and correctly pass the token to the AMD server using a site-specific submission method.

Task parameters

To bypass FunCaptcha on AMD DevCloud, the FunCaptchaTaskProxyless or FunCaptchaTask task type is used. The data[blob] parameter is not required for this site.

{
    "clientKey": "YOUR_API_KEY",
    "task": {
        "type": "FunCaptchaTaskProxyless",
        "websiteURL": "https://devcloud.amd.com/",
        "websitePublicKey": "06A0678C-C410-48EA-A18A-DC519C2B5877",
        "funcaptchaApiJSSubdomain": "https://eb15f.digitalocean.com"
    }
}

How to find parameters

websiteURL

This is the full address of the page where the captcha appears. For AMD DevCloud, this is the main page or the login page: https://devcloud.amd.com/

websitePublicKey

This is the Arkose Labs public key in UUID format.

1. Open the page and press F12 (DevTools).
2. Go to the Elements tab.
3. Press Ctrl+F and type data-pkey or public-key.
4. Copy the attribute value. For AMD DevCloud, it is 06A0678C-C410-48EA-A18A-DC519C2B5877.

Alternative method: Go to the Network tab, filter by Fetch/XHR or JS, find requests to arkoselabs.com or digitalocean.com. The public_key will be specified in the parameters.

surl

This parameter points to a custom API subdomain for Arkose Labs.

1. On the Elements tab, find the script tag that loads the captcha script.
2. Usually, it is a URL like https://eb15f.digitalocean.com/fc/api...
3. Copy the full domain URL (in this case, https://eb15f.digitalocean.com).

Integration specifics and useful recommendations

FunCaptcha can be complex to integrate, especially on sites with non-standard architecture like AMD DevCloud. Below are key recommendations to help you successfully set up the solution and avoid common issues.

Testing in Sandbox mode

Before moving to production automation, be sure to test your implementation in our Sandbox mode: https://2captcha.com/2captcha-api#sandbox. If the captcha appears and solves successfully in this mode, your code is likely working correctly. If errors occur, use the request parameter debugging guide: https://2captcha.com/2captcha-api#debugging.

data[blob] parameter

Many sites require passing an additional data[blob] parameter, which contains encrypted Arkose Labs session data. We have a detailed guide on how to correctly obtain and use this parameter: https://2captcha.com/h/funcaptcha-blob.

However, as we found out, blob is not required for AMD DevCloud — the token passes verification successfully without it. This simplifies integration, as there is no need to extract and pass additional data from network requests.

Using proxies

To avoid IP blocks from Arkose Labs, we strongly recommend using rotating residential proxies when solving FunCaptcha. Datacenter IP addresses often end up on blacklists, so for stable operation, it is better to use specifically rotating residential proxies.

Alternative solving methods

If you continue to face difficulties passing FunCaptcha on AMD DevCloud, you can try the grid-based solving method. This approach sometimes shows higher efficiency on specific types of tasks. More details can be found in our blog: https://2captcha.com/blog/funcaptcha-bypass-2-ways-solutions.

If you have specific questions during integration, feel free to contact support — we will be happy to help.

How to pass the token to AMD DevCloud

The specific feature of this site is that the token is not just inserted into a hidden field. After receiving the token from 2Captcha, we inject it via JavaScript fetch() in the browser (e.g., in Playwright), sending a POST request to the endpoint https://devcloud.amd.com/shield-service/arkose/v1/result.

The request body should look like this:

{
    "arkose_session_token": "TOKEN_FROM_2CAPTCHA",
    "session_id": "SESSION_ID"
}

session_id can usually be obtained from network requests or from global JavaScript variables on the page.

Code examples

Python + requests (Getting the token)

If you just need to get the token:

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.funcaptcha(
        sitekey='06A0678C-C410-48EA-A18A-DC519C2B5877',
        url='https://devcloud.amd.com/',
        surl='https://eb15f.digitalocean.com'
    )
    print(f"Token successfully received: {result['code']}")
    
except Exception as e:
    print(f"An error occurred: {e}")

Python + Playwright (Browser automation and token submission)

When automating a browser, we get the token and send it to the AMD server via fetch.

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

API_KEY = 'YOUR_API_KEY'
SITE_KEY = '06A0678C-C410-48EA-A18A-DC519C2B5877'
PAGE_URL = 'https://devcloud.amd.com/'

async def solve_and_submit():
    solver = TwoCaptcha(API_KEY)
    
    try:
        result = solver.funcaptcha(
            sitekey=SITE_KEY,
            url=PAGE_URL,
            surl='https://eb15f.digitalocean.com'
        )
        token = result['code']
        print(f"Captcha solved! Token: {token}")
        
        async with async_playwright() as p:
            browser = await p.chromium.launch(headless=False)
            page = await browser.new_page()
            
            await page.goto(PAGE_URL)
            await page.wait_for_selector('iframe[src*="arkoselabs"]', timeout=10000)
            
            # Get session_id from the page (example, needs to be adapted to the real site logic)
            session_id = await page.evaluate("() => { return window.sessionId || 'YOUR_SESSION_ID'; }")
            
            # Send the token via fetch to the AMD endpoint
            response = await page.evaluate(f"""
                async () => {{
                    const res = await fetch('https://devcloud.amd.com/shield-service/arkose/v1/result', {{
                        method: 'POST',
                        headers: {{
                            'Content-Type': 'application/json'
                        }},
                        body: JSON.stringify({{
                            arkose_session_token: '{token}',
                            session_id: '{session_id}'
                        }})
                    }});
                    return await res.json();
                }}
            """)
            
            print("Response from AMD server:", response)
            
            await asyncio.sleep(5)
            await browser.close()
            
    except Exception as e:
        print(f"Error: {e}")

asyncio.run(solve_and_submit())

Solution accuracy reports

If the site rejected the received token, be sure to report it via the reportIncorrect method. This helps the service improve its algorithms and refunds your funds for the failed attempt. If the token successfully passed the verification, send reportCorrect.

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
• FunCaptcha (Arkose Labs) documentation: https://2captcha.com/api-docs/arkoselabs-funcaptcha
• Detailed guide on submitting reports: https://2captcha.com/h/how-to-submit-reports
• Library for Python: https://github.com/2captcha/2captcha-python