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

reCAPTCHA v3 Enterprise Token Solving

Solve Google reCAPTCHA v3 Enterprise captchas with premium accuracy and score optimization support. Enterprise v3 provides score-based bot detection with advanced threat analysis for high-security applications, and our solver lets you target the score range your integration requires.

What is reCAPTCHA v3 Enterprise?

Google reCAPTCHA v3 Enterprise is the premium score-based captcha service built for organizations that need advanced threat intelligence and custom risk models. Unlike v2, it runs invisibly in the background and returns a risk score from 0.0 to 1.0. Higher scores indicate lower bot likelihood. Our solver supports the optional score parameter, which lets you target a specific score tier. Targeting higher scores requires additional browser simulation work and may consume more proxies, which increases processing time compared to the default mode.

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.score string optional Score optimization target: minimal, balanced, or maximum. Higher targets take longer and consume more proxies. Default behavior is balanced.
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',
        score: 'balanced',
        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, 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_ENTERPRISE_TOKEN',
        metadata: { siteUrl, siteKey },
        payload: {
          recaptchaAction: action,
          score: score,
          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',
  'balanced'
);
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, score='balanced'):
    payload_data = {
        'recaptchaAction': action,
        'score': score,
        'userAgent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
    }

    if s_value:
        payload_data['sValue'] = s_value

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

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

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

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

Score Optimization

The optional score parameter lets you control how aggressively our system optimizes the resulting reCAPTCHA v3 Enterprise score. The Enterprise API uses the same 0.0 to 1.0 risk scoring model as standard v3 but layers additional behavioral signals and custom risk models on top. Higher optimization targets require more browser simulation passes and additional proxy resources.

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. Enterprise sites with strict risk thresholds may benefit from this mode, but it increases processing time and consumes more proxy bandwidth. Use balanced for most integrations and only switch to maximum when tokens are being rejected.

Best Practices

Recommendations
  • Action Parameter: Always provide the correct recaptchaAction — it must match the action used on the target website exactly
  • Find Action: Search for grecaptcha.enterprise.execute in page source to find the correct action value
  • Score Mode: Start with balanced and only upgrade to maximum if the target site rejects your tokens
  • sValue Parameter: Some Enterprise sites include an additional "s" metadata value in their API call — provide it for better compatibility
  • User Agent: Use your actual browser user agent string to improve score consistency
  • Token Expiration: Enterprise v3 tokens expire within 2 minutes — submit to the target site immediately after receiving
  • Session Cookies: Pass session cookies when the target site uses cookie-based risk scoring

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.