Types de tâches

reCAPTCHA v2

Cette page a été traduite automatiquement à partir de la version chinoise et peut contenir des erreurs. La version chinoise fait foi.

Je ne suis pas un robotreCAPTCHAConfidentialité - Conditions

E-mailMot de passe••••••••Envoyerprotégé par reCAPTCHAConfidentialité - Conditions

Sélectionnez toutes les images avecdes voituresS'il n'y en a pas, cliquez sur Passer

012345678

Vérifier

IllustrationreCAPTCHA v2 : une case « Je ne suis pas un robot ». Un clic la coche aussitôt ou ouvre une épreuve d'images.

Une tâche reCAPTCHA v2 renvoie un token (gRecaptchaResponse) que vous soumettez au site cible pour réussir la vérification, sans cliquer sur des images. Le type le plus courant, NoCaptchaTaskProxyless, coûte 15 points (≈ $2.25 / 1k) par tâche et fonctionne en mode asynchrone : créez la tâche avec createTask, puis appelez getTaskResult toutes les 5 secondes pour obtenir le résultat. Les tâches en échec ou expirées donnent lieu à un remboursement de points automatique.

POSThttps://api.yescaptcha.com/createTaskEndpoint mondial

POSThttps://cn.yescaptcha.com/createTaskEndpoint Chine

Le corps de la requête est du JSON, authentifié avec votre clientKey (à copier depuis le tableau de bord de yescaptcha.com). Interrogez le résultat sur le même endpoint que celui où vous avez créé la tâche.

Cas d’usage

La page affiche une case « Je ne suis pas un robot » (I’m not a robot) : version case à cocher.
Il n’y a pas de case à cocher, et l’épreuve d’images n’apparaît qu’après un clic sur le bouton d’envoi : version invisible. Ajoutez "isInvisible": true.
La page charge recaptcha/enterprise.js, ou les URL de requête contiennent enterprise : version Enterprise. Utilisez un type dont le nom contient Enterprise.

Si vous ne savez pas de quelle version il s’agit, consultez Identifier le type de captcha. Si le taux de réussite des tokens n’est pas satisfaisant, essayez la reconnaissance d’images reCAPTCHA v2 : l’API vous indique les images sur lesquelles cliquer, et vous cliquez dans le navigateur.

Types et prix

Type de tâche	Prix	Mode	Remarques
`NoCaptchaTaskProxyless`	$2.25 / 1k; 15 points/tâche · ¥15 / 1k	Asynchrone
`RecaptchaV2TaskProxyless`	$3.00 / 1k; 20 points/tâche · ¥20 / 1k	Asynchrone	Mêmes paramètres que NoCaptchaTaskProxyless sur une autre route ; l'un peut servir de solution de secours à l'autre
`NoCaptchaTask`	$2.25 / 1k; 15 points/tâche · ¥15 / 1k	Asynchrone	Proxy fourni
`RecaptchaV2EnterpriseTaskProxyless`	$3.00 / 1k; 20 points/tâche · ¥20 / 1k	Asynchrone
`RecaptchaV2EnterpriseTask`	$3.00 / 1k; 20 points/tâche · ¥20 / 1k	Asynchrone	Proxy fourni

Les prix en dollars américains sont des estimations avec 1 USD ≈ ¥6.67 ; les tâches sont facturées en points.

NoCaptchaTaskProxyless et RecaptchaV2TaskProxyless ont les mêmes paramètres mais passent par des routes différentes. Si l’un a un taux de réussite insuffisant, essayez l’autre.
Les types sans Proxyless dans le nom (NoCaptchaTask, RecaptchaV2EnterpriseTask) chargent le captcha via votre propre proxy et nécessitent les champs proxyType, proxyAddress, proxyPort, etc. Utilisez-les lorsque le site cible contrôle l’IP du visiteur.

Paramètres de requête

Champs de l’objet task de createTask :

Champ	Type	Obligatoire	Description
`type`	string	Oui	Type de tâche ; voir « Types de tâches et prix » sur cette page
`websiteURL`	string	Oui	URL complète de la page qui affiche le captcha. Indiquez le site sur lequel vous voyez le captcha, pas le domaine du fournisseur du captcha
`websiteKey`	string	Oui	La clé du site (sitekey), à trouver dans le code source de la page ou dans les requêtes réseau ; elle ne change généralement pas
`isInvisible`	boolean	Non	Indiquez true pour la variante invisible ; omettez-le sinon
`proxyType`	string	Certains types	Protocole du proxy : `http`, `https`, `socks4` ou `socks5` (Obligatoire pour NoCaptchaTask, RecaptchaV2EnterpriseTask)
`proxyAddress`	string	Certains types	Adresse IP ou nom d'hôte du proxy. Les adresses locales ou privées telles que 127.0.0.1 ou 192.168.x.x ne fonctionneront pas, car nos serveurs ne peuvent pas y accéder (Obligatoire pour NoCaptchaTask, RecaptchaV2EnterpriseTask)
`proxyPort`	integer	Certains types	Port du proxy (Obligatoire pour NoCaptchaTask, RecaptchaV2EnterpriseTask)
`proxyLogin`	string	Non	Nom d'utilisateur du proxy, si le proxy exige une authentification (NoCaptchaTask, RecaptchaV2EnterpriseTask uniquement)
`proxyPassword`	string	Non	Mot de passe du proxy, si le proxy exige une authentification (NoCaptchaTask, RecaptchaV2EnterpriseTask uniquement)
`userAgent`	string	Non	User-Agent du navigateur. Si le résultat contient un `userAgent`, utilisez cette valeur lorsque vous soumettez le token (NoCaptchaTask, RecaptchaV2EnterpriseTask uniquement)
`enterprisePayload`	object	Non	Paramètres supplémentaires de la version Enterprise, comme la valeur `s` de reCAPTCHA Enterprise : `{"s": "..."}`. Omettez-le si la page ne l'utilise pas (RecaptchaV2EnterpriseTaskProxyless, RecaptchaV2EnterpriseTask uniquement)

Pour trouver websiteURL et websiteKey, consultez Trouver les paramètres reCAPTCHA.

Exemple de requête

Avec la page de démonstration officielle de Google :

{
  "clientKey": "YOUR_CLIENT_KEY",
  "task": {
    "type": "NoCaptchaTaskProxyless",
    "websiteURL": "https://www.google.com/recaptcha/api2/demo",
    "websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"
  }
}

Code complet qui crée la tâche, interroge le résultat toutes les 5 secondes et affiche le token. Avant de l’exécuter, placez votre ClientKey dans la variable d’environnement YESCAPTCHA_CLIENT_KEY :

curl -s https://api.yescaptcha.com/createTask \
  -H 'Content-Type: application/json' \
  -d '{
  "clientKey": "YOUR_CLIENT_KEY",
  "task": {
    "type": "NoCaptchaTaskProxyless",
    "websiteURL": "https://www.google.com/recaptcha/api2/demo",
    "websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"
  }
}'

# Returns {"errorId":0,"taskId":"..."}; then poll every 5 seconds:
curl -s https://api.yescaptcha.com/getTaskResult \
  -H 'Content-Type: application/json' \
  -d '{"clientKey": "YOUR_CLIENT_KEY", "taskId": "TASK_ID"}'

import os
import time

import requests

API = "https://api.yescaptcha.com"
CLIENT_KEY = os.environ["YESCAPTCHA_CLIENT_KEY"]  # Read the clientKey from an environment variable


def call(method, payload):
    r = requests.post(f"{API}/{method}", json={"clientKey": CLIENT_KEY, **payload}, timeout=30)
    data = r.json()
    if data.get("errorId"):
        raise RuntimeError(f"{data.get('errorCode')}: {data.get('errorDescription')}")
    return data


def solve(task):
    task_id = call("createTask", {"task": task})["taskId"]
    for _ in range(36):  # Poll every 5 seconds, for up to about 3 minutes
        time.sleep(5)
        result = call("getTaskResult", {"taskId": task_id})
        if result.get("status") == "ready":
            return result["solution"]
    raise TimeoutError(task_id)


solution = solve({
    "type": "NoCaptchaTaskProxyless",
    "websiteURL": "https://www.google.com/recaptcha/api2/demo",
    "websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
})
print(solution["gRecaptchaResponse"])

const API = 'https://api.yescaptcha.com';
const CLIENT_KEY = process.env.YESCAPTCHA_CLIENT_KEY; // Read the clientKey from an environment variable

async function call(method, payload) {
  const res = await fetch(`${API}/${method}`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ clientKey: CLIENT_KEY, ...payload }),
  });
  const data = await res.json();
  if (data.errorId) throw new Error(`${data.errorCode}: ${data.errorDescription}`);
  return data;
}

async function solve(task) {
  const { taskId } = await call('createTask', { task });
  for (let i = 0; i < 36; i++) { // Poll every 5 seconds, for up to about 3 minutes
    await new Promise((r) => setTimeout(r, 5000));
    const result = await call('getTaskResult', { taskId });
    if (result.status === 'ready') return result.solution;
  }
  throw new Error(`timeout: ${taskId}`);
}

const solution = await solve({
  type: "NoCaptchaTaskProxyless",
  websiteURL: "https://www.google.com/recaptcha/api2/demo",
  websiteKey: "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
});
console.log(solution.gRecaptchaResponse);

Pour la version Enterprise, si la page transmet une valeur s à reCAPTCHA, placez-la dans enterprisePayload :

{
  "clientKey": "YOUR_CLIENT_KEY",
  "task": {
    "type": "RecaptchaV2EnterpriseTaskProxyless",
    "websiteURL": "https://example.com/login",
    "websiteKey": "SITE_KEY_OF_THE_PAGE",
    "enterprisePayload": {
      "s": "S_VALUE_FROM_THE_PAGE"
    }
  }
}

Avec votre propre proxy :

{
  "clientKey": "YOUR_CLIENT_KEY",
  "task": {
    "type": "NoCaptchaTask",
    "websiteURL": "https://www.google.com/recaptcha/api2/demo",
    "websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
    "proxyType": "http",
    "proxyAddress": "proxy.example.com",
    "proxyPort": 8080,
    "proxyLogin": "user",
    "proxyPassword": "pass"
  }
}

Résultat

createTask renvoie un ID de tâche :

{
  "errorId": 0,
  "taskId": "61138bb6-19fb-11ec-a9c8-0242ac110006"
}

Utilisez-le pour appeler getTaskResult. Tant que la tâche est en cours, la réponse est {"errorId": 0, "status": "processing"} ; interrogez à nouveau 5 secondes plus tard. Lorsque la tâche est terminée :

{
  "errorId": 0,
  "status": "ready",
  "solution": {
    "gRecaptchaResponse": "03AGdBq25SxXT-pmSeBXjzScW-EiocHwwpwqtk1QXlJnGnU..."
  }
}

Champ	Type	Description
`gRecaptchaResponse`	string	Le token à soumettre au site cible. Usage unique, valable environ 120 secondes ; utilisez-le dans les 60 secondes

Une tâche est traitée pendant 110 secondes environ au maximum ; au-delà, elle renvoie ERROR_TASK_TIMEOUT et les points sont remboursés. En cas d’erreur, errorId vaut 1 ; traitez-la selon errorCode, voir Codes d’erreur. Pour savoir comment soumettre le token, consultez Réussir un reCAPTCHA avec un token.

FAQ

Pourquoi les tokens d’un même site réussissent-ils parfois et échouent-ils parfois ?

C’est le site cible qui décide. Il attribue un score à chaque vérification et applique un seuil qu’il peut modifier à tout moment : le taux de réussite varie donc selon les sites, et tous les tokens ne passent pas. Comparez avec un autre type de tâche pour le même captcha, ou passez à la reconnaissance d’images.

Combien de temps un token reste-t-il valide ?

Un token est à usage unique et valable environ 120 secondes. Soumettez-le dans les 60 secondes. Cette durée est fixée par Google.

Les points sont-ils débités en cas d’échec ?

Non. Les tâches qui renvoient ERROR_CAPTCHA_UNSOLVABLE ou qui expirent donnent lieu à un remboursement de points automatique. Voir Facturation et remboursements.