Chat with us, powered by LiveChat
← Return to MyDisct Solver

reCAPTCHA v3 Token Solving

Solve Google reCAPTCHA v3 invisible captchas. reCAPTCHA v3 returns a score (0.0-1.0) indicating bot likelihood. No user interaction required - completely invisible verification.

What is reCAPTCHA v3 Token?

Google reCAPTCHA v3 is the latest version that works completely in the background. Unlike v2, it doesn't require any user interaction and returns a score from 0.0 to 1.0 indicating the likelihood that the user is a bot. Higher scores indicate more trustworthy users. Our service generates valid tokens with high scores.

Captcha Type 

"type": "RECAPTCHA_V3_TOKEN"

Request Format

POST /createTask

Request Parameters

Parameter Type Required Description
captcha.type string required Must be "RECAPTCHA_V3_TOKEN"
captcha.metadata.siteUrl string required URL where captcha appears
captcha.metadata.siteKey string required reCAPTCHA v3 site key
captcha.payload.recaptchaAction string optional Action parameter from the site (e.g., "login", "submit", "homepage"). Default: "verify"
captcha.payload.userAgent string optional Your browser's user agent to improve solving accuracy
captcha.payload.cookies array optional Array of cookie objects (see Cookie Object Structure below)
captcha.payload.cookies[].name string required* Cookie name
captcha.payload.cookies[].value string required* Cookie value
captcha.payload.cookies[].domain string required* Cookie domain (e.g., ".example.com")
captcha.payload.cookies[].path string optional Cookie path (defaults to "/")
captcha.payload.domain string optional reCAPTCHA API endpoint domain if the site uses an alternative
captcha.payload.proxy object optional Proxy configuration object
captcha.payload.proxy.protocol string required* Proxy protocol: "http", "https", "socks4", "socks5"
captcha.payload.proxy.host string required* Proxy IP address
captcha.payload.proxy.port number required* Proxy port number
captcha.payload.proxy.username string optional Proxy authentication username
captcha.payload.proxy.password string optional Proxy authentication password

* Required only if proxy object is provided

Example Request

JavaScript 
const response = await fetch('https://solver-api.mydisct.com/createTask', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'apikey': 'YOUR_API_KEY'
  },
  body: JSON.stringify({
    auth: { token: 'YOUR_API_KEY' },
    context: { source: 'api', version: '1.0.0' },
    captcha: {
      type: 'RECAPTCHA_V3_TOKEN',
      metadata: {
        siteUrl: 'https://example.com',
        siteKey: '6LdyC2cUAAAAACGuDKpXeDorzUDWXmdqeg-xy696'
      },
      payload: {
        recaptchaAction: 'login',  // Action from the site (optional, default: "verify")
        userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36...',  // Your browser UA
        cookies: [
          { name: 'session_id', value: 'abc123', domain: '.example.com' },
          { name: 'auth_token', value: 'xyz789', domain: '.example.com' }
        ],
        domain: 'google.com',  // Alternative API domain if used by site
        proxy: {
          protocol: 'http',
          host: '1.2.3.4',
          port: 8080,
          username: 'proxyuser',
          password: 'proxypass'
        }
      }
    }
  })
});

const data = await response.json();
console.log('Task ID:', data.task.id);

Response Format

JSON 
{
  "success": true,
  "service": "MyDisct Solver",
  "message": "Captcha is being processed",
  "task": {
    "id": "MyDisctSolver_abc123",
    "status": "processing"
  }
}

Fetch Result Response (Processing)

JSON 
{
  "success": true,
  "service": "MyDisct Solver",
  "message": "Captcha is being processed",
  "task": {
    "id": "MyDisctSolver_abc123",
    "status": "processing"
  }
}

Fetch Result Response (Completed)

JSON 
{
  "success": true,
  "service": "MyDisct Solver",
  "message": "Captcha solved successfully",
  "task": {
    "id": "MyDisctSolver_abc123",
    "status": "completed",
    "result": {
      "token": "03AGdBq26QF...",
      "timestamp": "2025-11-05T12:34:56.789Z"
    }
  }
}

Implementation Guide

Step 1: Extract reCAPTCHA v3 Site Key and Action

reCAPTCHA v3 requires both the site key and the action parameter. Here's how to find them:

JavaScript 
// Method 1: Find site key from script tag
function getRecaptchaV3SiteKey() {
  const scripts = document.querySelectorAll('script');
  for (const script of scripts) {
    const match = script.src?.match(/recaptcha\/api\.js\?render=([^&]+)/);
    if (match) return match[1];
  }
  
  
  return null;
}

const siteKey = getRecaptchaV3SiteKey();
console.log('Site Key:', siteKey);
Finding the Action Parameter

The action parameter is defined by the website and is used to identify different user actions. Search the page source code for grecaptcha.execute - the action is the second parameter. Common values include: login, submit, register, homepage, contact. If you can't find it, try using verify as a default.

Step 2: Solve reCAPTCHA v3 Token

JavaScript 
async function solveRecaptchaV3Token(siteUrl, siteKey, action = 'verify') {
  const createResponse = await fetch('https://solver-api.mydisct.com/createTask', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'apikey': 'YOUR_API_KEY'
    },
    body: JSON.stringify({
      auth: { token: 'YOUR_API_KEY' },
      context: { source: 'api', version: '1.0.0' },
      captcha: {
        type: 'RECAPTCHA_V3_TOKEN',
        metadata: { siteUrl, siteKey },
        payload: {
          recaptchaAction: action  // Important: use the correct action from the site
        }
      }
    })
  });

  const createData = await createResponse.json();
  if (!createData.success) throw new Error(createData.error.message);

  const taskId = createData.task.id;

  while (true) {
    await new Promise(resolve => setTimeout(resolve, 5000));

    const resultResponse = await fetch('https://solver-api.mydisct.com/fetchResult', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'apikey': 'YOUR_API_KEY'
      },
      body: JSON.stringify({ taskId })
    });

    const resultData = await resultResponse.json();
    if (resultData.task.status === 'completed') {
      return resultData.task.result.token;
    } else if (resultData.task.status === 'failed') {
      throw new Error('Token solving failed');
    }
  }
}

const token = await solveRecaptchaV3Token(
  'https://example.com/login',
  '6LdyC2cUAAAAACGuDKpXeDorzUDWXmdqeg-xy696',
  'login'  // Action from the site
);

console.log('reCAPTCHA v3 Token:', token);

Python Example

Python 
import requests
import time

def solve_recaptcha_v3(site_url, site_key, api_key, recaptcha_action='verify'):
    """
    Solve reCAPTCHA v3 token challenge
    
    Args:
        site_url: URL where captcha appears
        site_key: reCAPTCHA v3 site key
        api_key: Your MyDisct Solver API key
        recaptcha_action: Action parameter from the site (default: 'verify')
    
    Returns:
        reCAPTCHA v3 response token
    """
    create_response = requests.post(
        'https://solver-api.mydisct.com/createTask',
        headers={'Content-Type': 'application/json', 'apikey': api_key},
        json={
            'auth': {'token': api_key},
            'context': {'source': 'api', 'version': '1.0.0'},
            'captcha': {
                'type': 'RECAPTCHA_V3_TOKEN',
                'metadata': {
                    'siteUrl': site_url,
                    'siteKey': site_key
                },
                'payload': {
                    'recaptchaAction': action
                }
            }
        }
    )
    
    create_data = create_response.json()
    if not create_data['success']:
        raise Exception(create_data['error']['message'])
    
    task_id = create_data['task']['id']
    print(f'Task created: {task_id}')
    
    while True:
        time.sleep(5)
        result_response = requests.post(
            'https://solver-api.mydisct.com/fetchResult',
            headers={'Content-Type': 'application/json', 'apikey': api_key},
            json={'taskId': task_id}
        )
        
        result_data = result_response.json()
        if result_data['task']['status'] == 'completed':
            return result_data['task']['result']['token']
        elif result_data['task']['status'] == 'failed':
            raise Exception('Token solving failed')
        
        print('Waiting for solution...')

# Example usage
token = solve_recaptcha_v3(
    site_url='https://example.com',
    site_key='6LdyC2cUAAAAACGuDKpXeDorzUDWXmdqeg-xy696',
    api_key='YOUR_API_KEY',
    recaptcha_action='login'  # Action from the site
)

print(f'reCAPTCHA v3 Token: {token}')

response = requests.post(
    'https://example.com/submit',
    data={'g-recaptcha-response': token}
)
print(f'Status: {response.status_code}')

Best Practices

Recommendations
  • reCAPTCHA v3 is completely invisible - no user interaction required
  • Returns high score (0.7-1.0) for human-like behavior
  • Action parameter: Extract the action value from the site's JavaScript code (e.g., "login", "submit", "homepage")
  • Tokens expire after 2 minutes - use immediately after receiving
  • Use proxy if required by the target website for better success rates

Common Issues

Issue: Low score returned

Solution: Ensure you are using a high-quality proxy and a consistent user agent. Google lowers scores for suspicious IP addresses or mismatched user agents.

Issue: Token invalid

Solution: Tokens expire quickly (2 minutes). Ensure you are using the token immediately after receiving it. Also verify the site key and action parameter.

Issue: Wrong action parameter

Solution: The action parameter must match exactly what the website expects. Search the page source for grecaptcha.execute to find the correct action value. Using the wrong action will result in token rejection.