reCAPTCHA v3 Token Solving

Solve Google reCAPTCHA v3 invisible captchas with score optimization support. reCAPTCHA v3 returns a score from 0.0 to 1.0 indicating bot likelihood, and our solver lets you target the score range you need. 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 does not require any user interaction and returns a score from 0.0 to 1.0 indicating how likely the user is to be a bot. Higher scores indicate more trustworthy behavior. Our service generates valid tokens and optionally lets you target a specific score tier through the score parameter. Targeting higher scores requires additional browser simulation work and may use more proxies, which increases processing time.

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.score`	string	optional	Score optimization target: `minimal`, `balanced`, or `maximum`. Higher targets take longer and consume more proxies. Default behavior is `balanced`.
`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',
        score: 'balanced',
        userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36...',
        cookies: [
          { name: 'session_id', value: 'abc123', domain: '.example.com' },
          { name: 'auth_token', value: 'xyz789', domain: '.example.com' }
        ],
        domain: 'google.com',
        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', score = 'balanced') {
  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,
          score: score
        }
      }
    })
  });

  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',
  'balanced'
);

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', score='balanced'):
    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': recaptcha_action,
                    'score': score
                }
            }
        }
    )
    
    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',
    score='balanced'
)

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

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

    
        
            
            Score Optimization
        

        
            The optional score parameter lets you control how aggressively our system optimizes the
            resulting reCAPTCHA v3 score. Google evaluates browser fingerprinting, behavioral signals, and navigation
            history when assigning a score. Higher optimization levels require more browser simulation passes and
            additional proxy resources, so they naturally take more time to complete.
        

        
            
                
                    Value
                    Expected Score Range
                    Processing Time
                    Proxy Usage
                
            
            
                
                    minimal
                    0.3 - 0.6
                    Fastest
                    Low
                
                
                    balanced
                    0.5 - 0.8
                    Normal
                    Moderate
                
                
                    maximum
                    0.7 - 1.0
                    Slower (up to 2x)
                    Higher
                
            
        

        
            
                
                Maximum Score Mode Notice
            
            
                Using score: "maximum" triggers additional browser journey simulation and multi-page
                navigation behavior. This increases processing time and consumes more proxy bandwidth. Only use
                maximum mode when the target site strictly enforces high score thresholds. For most use cases,
                balanced provides the right combination of speed and score quality.
            
        
    

    
        
            
            Best Practices
        

        
            
                
                Recommendations
            
            
                reCAPTCHA v3 is completely invisible. No user interaction required.
                The default balanced score mode works well for the vast majority of sites
                Only switch to maximum when the target site requires scores above 0.7 and your attempts are being rejected
                Action parameter: Extract the action value from the sites JavaScript code by searching for grecaptcha.execute calls
                Tokens expire after 2 minutes. Submit to the target site immediately after receiving.
                Provide your actual browser user agent when possible to improve score consistency
                Pass site cookies when the target site uses session-based scoring
            
        
    

    
        
            
            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.
            
        
    

    
        
            
            Related Documentation
        

        
            
                
                    reCAPTCHA v2 Token
                    
                        Checkbox-based verification
                    
                
            

            
                
                    reCAPTCHA Enterprise Token
                    
                        Enterprise-grade protection
                    
                
            

            
                
                    Cloudflare Turnstile Token
                    
                        Invisible verification

Value	Expected Score Range	Processing Time	Proxy Usage
`minimal`	0.3 - 0.6	Fastest	Low
`balanced`	0.5 - 0.8	Normal	Moderate
`maximum`	0.7 - 1.0	Slower (up to 2x)	Higher