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

reCAPTCHA v3 Enterprise Token Solving

Solve Google reCAPTCHA v3 Enterprise captchas with premium accuracy. Enterprise v3 provides score-based bot detection with advanced threat analysis for high-security applications.

What is reCAPTCHA v3 Enterprise?

Google reCAPTCHA v3 Enterprise is the premium score-based captcha service. Unlike v2, it runs invisibly in the background and returns a risk score (0.0 to 1.0) instead of requiring user interaction. Enterprise version includes advanced threat analysis, custom risk models, and enterprise-grade analytics. The recaptchaAction parameter is important for v3 as it helps identify the context of the user action.

Captcha Type 

"type": "RECAPTCHA_V3_ENTERPRISE_TOKEN"

Request Format

POST /createTask

Request Parameters

Parameter Type Required Description
auth.token string required Your API key
captcha.type string required Must be "RECAPTCHA_V3_ENTERPRISE_TOKEN"
captcha.metadata.siteUrl string required The URL where the captcha appears
captcha.metadata.siteKey string required reCAPTCHA Enterprise site key
captcha.payload.recaptchaAction string recommended The action name (e.g., "login", "submit", "register")
captcha.payload.sValue string optional The "s" metadata value (required by some Enterprise sites)
captcha.payload.userAgent string optional User agent string for solving
captcha.payload.cookies array optional Array of cookie objects
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.proxy object optional Proxy configuration (recommended for Enterprise)
captcha.payload.proxy.protocol string required* Proxy protocol: "http", "https", "socks4", or "socks5"
captcha.payload.proxy.host string required* Proxy IP address or hostname
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 parent object (proxy/cookies) is provided

About recaptchaAction

The recaptchaAction parameter is important for reCAPTCHA v3. It should match the action used on the target website. Common values include: login, submit, register, checkout, verify. Check the website's source code to find the correct action value.

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_ENTERPRISE_TOKEN',
      metadata: {
        siteUrl: 'https://example.com/login',
        siteKey: '6LcxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxAA'
      },
      payload: {
        recaptchaAction: 'login',
        userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
        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

Create Task Response (Processing)

{
  "success": true,
  "service": "MyDisct Solver",
  "message": "Captcha task created successfully",
  "task": {
    "id": "MyDisctSolver_abc123",
    "status": "processing"
  }
}

Fetch Result Response (Processing)

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

Fetch Result Response (Completed)

{
  "success": true,
  "service": "MyDisct Solver",
  "message": "Captcha solved successfully",
  "task": {
    "id": "MyDisctSolver_abc123",
    "status": "completed",
    "result": {
      "token": "03AGdBq24PBCbwiDRaS_MJ7Z...",
      "timestamp": "2025-12-13T12:00:00.000Z"
    }
  }
}
Understanding the Response

The token field contains the reCAPTCHA v3 Enterprise response token. This token is submitted to Google's verification endpoint along with the action. The server then receives a risk score (0.0 to 1.0) to determine if the request is legitimate.

Implementation Guide

Step 1: Extract Action and Site Key

// Find reCAPTCHA v3 Enterprise action from page
function getRecaptchaV3Action() {
  const scripts = document.querySelectorAll('script');
  for (const script of scripts) {
    const match = script.textContent?.match(/grecaptcha.enterprise.execute([^,]+,s*{action:s*['"]([^'"]+)['"]}/);
    if (match) return match[1];
  }

  const recaptchaDiv = document.querySelector('[data-action]');
  if (recaptchaDiv) {
    return recaptchaDiv.getAttribute('data-action');
  }

  return 'submit'; // or 'login', 'register', etc.
}

function getEnterpriseSiteKey() {
  const scripts = document.querySelectorAll('script');
  for (const script of scripts) {
    const match = script.src?.match(/render=([^&]+)/);
    if (match) return match[1];
  }

  for (const script of scripts) {
    const match = script.textContent?.match(/grecaptcha.enterprise.execute(['"]([^'"]+)['"]/);
    if (match) return match[1];
  }

  return null;
}

const siteKey = getEnterpriseSiteKey();
const action = getRecaptchaV3Action();
console.log('Site Key:', siteKey, 'Action:', action);

Step 2: Solve Enterprise v3 Token

JavaScript 
async function solveRecaptchaV3Enterprise(siteUrl, siteKey, action) {
  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_ENTERPRISE_TOKEN',
        metadata: { siteUrl, siteKey },
        payload: {
          recaptchaAction: action,
          userAgent: navigator.userAgent
        }
      }
    })
  });

  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('Enterprise v3 token solving failed');
    }
  }
}

const token = await solveRecaptchaV3Enterprise(
  'https://example.com/login',
  '6LcxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxAA',
  'login'
);
console.log('Enterprise v3 Token:', token);

Step 3: Submit Token

// Submit v3 Enterprise token with API request
async function submitWithV3Token(token) {
  const response = await fetch('https://example.com/api/login', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      username: 'myusername',
      password: 'mypassword',
      'g-recaptcha-response': token
    })
  });

  return await response.json();
}

Python Example

Python 
import requests
import time

def solve_recaptcha_v3_enterprise(site_url, site_key, action, api_key, s_value=None):
    """Solve reCAPTCHA v3 Enterprise token challenge"""

    payload_data = {
        'recaptchaAction': action,
        'userAgent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
    }
    
    # Add sValue if provided
    if s_value:
        payload_data['sValue'] = s_value

    # Step 1: Create task
    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_ENTERPRISE_TOKEN',
                'metadata': {
                    'siteUrl': site_url,
                    'siteKey': site_key
                },
                'payload': payload_data
            }
        }
    )

    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}')

    # Step 2: Poll for result
    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('Enterprise v3 token solving failed')

        print('Waiting for solution...')

# Example usage
token = solve_recaptcha_v3_enterprise(
    site_url='https://example.com/login',
    site_key='6LcxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxAA',
    action='login',
    api_key='YOUR_API_KEY'
)

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

# Submit with API request
response = requests.post(
    'https://example.com/api/login',
    headers={'Content-Type': 'application/json'},
    json={
        'username': 'myusername',
        'password': 'mypassword',
        'g-recaptcha-response': token
    }
)

print(f'Login response: {response.status_code}')

Best Practices

Recommendations
  • Action Parameter: Always provide the correct recaptchaAction - it must match the action used on the target website
  • Find Action: Search for grecaptcha.enterprise.execute in page source to find the action value
  • sValue Parameter: Some Enterprise sites require the "s" metadata value
  • User Agent: Use a realistic user agent string matching the target platform
  • Token Expiration: v3 tokens expire quickly (~2 minutes), use immediately
  • Score Threshold: v3 uses scores (0.0-1.0), our tokens typically achieve high scores

Common Issues

Issue: Low score / Token rejected

Solution: Ensure the recaptchaAction parameter matches exactly what the website uses. Wrong action values result in low scores and rejected tokens.

Issue: Action mismatch error

Solution: The action in your token must match the action the server expects. Check the website's JavaScript for grecaptcha.enterprise.execute calls to find the correct action value.

Issue: v2 vs v3 confusion

Solution: v3 runs invisibly without user interaction. If you see a checkbox or image challenge, use RECAPTCHA_V2_ENTERPRISE_TOKEN instead.