Erreurs et correctifs courants de GeeTest v3

La plupart des échecs de GeeTest v3 se répartissent en trois catégories : erreurs au stade de la demande (soumission à l'API), erreurs au stade du résultat (interrogation de la réponse) et échecs de validation de la page cible (l'API renvoie des valeurs mais la page les rejette toujours). Le plus gros problème spécifique à GeeTest est presque toujours le même : une valeur challenge obsolète.

CaptchaAIDocumentation sur l'API GeeTest v3sont explicites : vous devez obtenir une nouvelle valeur challenge pour chaque requête de résolution. Une fois le captcha chargé sur la page, l'ancien défi devient invalide. Cela signifie qu'une intégration GeeTest peut échouer même lorsque la demande semble généralement correcte.

Ce guide passe en revue tous les modèles de panne courants et la solution la plus rapide pour chacun.

L'échec n°1 du GeeTest : challenge obsolète

S’il y a bien une chose à vérifier en premier, c’est bien le défi de la fraîcheur.

GeeTest v3 nécessite deux paramètres clés :

• gt — la clé publique du site Web (statique, ne change pas)
• challenge — la clé de défi dynamique (change à chaque chargement de page)

Pourquoi ça casse

La valeur challenge est générée lorsque le widget GeeTest s'initialise sur la page. Si vous le capturez une fois et le réutilisez sur plusieurs requêtes de résolution, chaque requête après la première :

• être rejeté par l'API au moment de la soumission, ou
• produire un résultat que la page cible rejette car le défi a expiré

Comment y remédier

Avant chaque demande de résolution, inspectez les requêtes réseau de la page pour trouver l'appel API qui renvoie un nouveau challenge. Rejouez cette demande pour obtenir une nouvelle valeur, puis soumettez-la immédiatement à CaptchaAI.

# Pseudocode: fetch a fresh challenge before each solve
import requests

def get_fresh_challenge(target_url):
    """Hit the GeeTest init endpoint to get a new challenge."""
    resp = requests.get(f"{target_url}/geetest/register", timeout=10)
    data = resp.json()
    return data["challenge"], data["gt"]

challenge, gt = get_fresh_challenge("https://example.com")
# Now submit to CaptchaAI immediately — do not delay

Règle générale : Si le temps entre la capture du challenge et la soumission de la demande de résolution est supérieur à quelques secondes, actualisez-le.

Erreurs au stade de la demande

Ces échecs se produisent lorsque vous soumettez la tâche à https://ocr.captchaai.com/in.php.

ERROR_WRONG_USER_KEY

Cause : Le format de la clé API est incorrect (il doit contenir 32 caractères).

Correction : Vérifiez la clé decaptchaai.com/api.php. N'ajoutez pas de caractères supplémentaires ni d'espaces.

ERROR_KEY_DOES_NOT_EXIST

Cause : La clé API est correctement formatée mais ne correspond à aucun compte actif.

Correction : Connectez-vous à votre tableau de bord CaptchaAI et confirmez que votre clé est active.

ERROR_ZERO_BALANCE

Cause : Aucun fil de discussion gratuit n'est disponible avec votre forfait actuel.

Correction : Attendez que les threads se libèrent, réduisez la simultanéité ou mettez à niveau votre forfait.

ERROR_PAGEURL

Cause : Le paramètre pageurl est absent de la requête.

Correction : Ajoutez l'URL complète de la page sur laquelle le widget GeeTest se charge. Exemple :

pageurl=https://example.com/login

ERROR_BAD_PARAMETERS

Cause : Un ou plusieurs champs obligatoires sont manquants ou mal remplis. Pour GeeTest, les paramètres requis sont :

Correction : Vérifiez que gt, challenge et pageurl sont tous présents et correctement formatés.

Réponses HTML ou 500/502

Cause : Erreur transitoire côté serveur – il ne s'agit pas d'un problème de paramètre.

Correction : Attendez 5 à 10 secondes, puis réessayez la demande.

Erreurs au stade du résultat

Ces échecs se produisent lorsque vous interrogez https://ocr.captchaai.com/res.php.

CAPCHA_NOT_READY

Ce n'est pas une erreur. Cela signifie que le captcha est toujours en cours de résolution. Les résolutions de GeeTest v3 sur CaptchaAI prennent généralement moins de 12 secondes avec un taux de réussite de 100 %.

Correction : Attendez 5 secondes et interrogez à nouveau. Ne considérez pas cela comme un échec.

ERROR_WRONG_ID_FORMAT

Cause : Le format de l'ID captcha est incorrect : les identifiants doivent être uniquement numériques.

Correction : Vérifiez que vous utilisez l'ID exact renvoyé par in.php, sans modification.

ERROR_WRONG_CAPTCHA_ID

Cause : L'ID ne correspond à aucune tâche soumise.

Correction : Vérifiez que vous utilisez le bon identifiant indiqué dans la réponse à l'envoi. Si vous avez soumis plusieurs tâches, assurez-vous d'interroger la bonne.

ERROR_EMPTY_ACTION

Cause : Le paramètre action est manquant ou vide dans votre demande d'interrogation.

Correction : Incluez action=get dans chaque demande de sondage :

https://ocr.captchaai.com/res.php?key=YOUR_KEY&action=get&id=CAPTCHA_ID

ERROR_CAPTCHA_UNSOLVABLE

Cause : Le défi n'a pas pu être résolu, probablement en raison d'une valeur challenge obsolète ou d'une variante GeeTest non prise en charge.

Correction : Actualisez la valeur challenge et réessayez.

ERROR_INTERNAL_SERVER_ERROR

Cause : Problème côté serveur sur CaptchaAI.

Correction : Attendez 10 secondes et réessayez.

Échecs de validation de la page cible

Ce sont les échecs les plus difficiles à déboguer car l'API CaptchaAI renvoie un résultat valide, mais la page cible le rejette toujours.

Lorsqu'une résolution GeeTest v3 réussit, l'API renvoie trois valeurs :

{
  "challenge": "1a2b3456cd67890e12345fab678901c2de",
  "validate": "09fe8d7c6ba54f32e1dcb0a9fedc8765",
  "seccode": "12fe3d4c56789ba01f2e345d6789c012|jordan"
}

Ceux-ci doivent être soumis à la page cible comme :

Échec 1 : mappage de champ incorrect

Symptôme : L'API renvoie des valeurs, mais la page cible les rejette immédiatement.

Cause : Les valeurs renvoyées sont insérées dans les mauvais champs ou dans le mauvais chemin de requête.

Correction : Inspectez le trafic réseau à partir d'une résolution manuelle GeeTest sur la page cible. Recherchez la requête POST qui soumet le résultat du GeeTest et faites correspondre exactement les noms de vos champs.

Échec 2 : challenge périmé utilisé en amont

Symptôme : L'API renvoie des valeurs, mais la page indique que le défi est expiré ou non valide.

Cause : La valeur challenge a été capturée trop tôt ou réutilisée.

Correction : Récupérez un nouveau challenge immédiatement avant chaque demande de résolution. Ne le mettez pas en cache et ne le réutilisez pas.

Échec 3 : mauvais contexte de page

Symptôme : La validation échoue même avec de nouvelles entrées.

Cause : Le pageurl envoyé à CaptchaAI ne correspond pas à la page réelle sur laquelle le widget GeeTest a été chargé.

Correction : Utilisez l'URL exacte, y compris le protocole et le chemin. Si le widget est chargé via AJAX sur une route différente, utilisez l'URL de cette route.

Échec 4 : inadéquation de la structure de la demande

Symptôme : Les champs sont corrects mais le format de la demande est incorrect.

Cause : La page cible attend les champs GeeTest dans un type de contenu spécifique (par exemple, corps JSON ou encodé par formulaire) ou à côté d'autres champs de formulaire.

Correction : Comparez votre demande de soumission au trafic réseau à partir d'une résolution manuelle. Faites correspondre le type de contenu, l'ordre des champs et tous les champs supplémentaires.

Référence rapide pour corriger les erreurs

Python : terminez la résolution de GeeTest v3 avec un nouveau défi

import time
import requests

API_KEY = "YOUR_CAPTCHAAI_API_KEY"

SUBMIT_URL = "https://ocr.captchaai.com/in.php"
RESULT_URL = "https://ocr.captchaai.com/res.php"


def get_fresh_challenge(target_url):
    """Fetch a fresh GeeTest challenge from the target page."""
    resp = requests.get(f"{target_url}/api/geetest/register", timeout=10)
    data = resp.json()
    return data["gt"], data["challenge"]


def solve_geetest_v3(api_key, gt, challenge, pageurl):
    """Submit a GeeTest v3 challenge and return the validation package."""

    # Submit
    submit_resp = requests.post(
        SUBMIT_URL,
        data={
            "key": api_key,
            "method": "geetest",
            "gt": gt,
            "challenge": challenge,
            "pageurl": pageurl,
            "json": 1,
        },
        timeout=30,
    )
    submit_resp.raise_for_status()
    submit_data = submit_resp.json()

    if submit_data.get("status") != 1:
        raise RuntimeError(f"Submit failed: {submit_data}")

    captcha_id = submit_data["request"]
    print(f"Task created — captcha ID: {captcha_id}")

    # Wait before first poll
    time.sleep(15)

    # Poll for result
    for _ in range(60):
        result_resp = requests.get(
            RESULT_URL,
            params={
                "key": api_key,
                "action": "get",
                "id": captcha_id,
                "json": 1,
            },
            timeout=30,
        )
        result_resp.raise_for_status()
        result_data = result_resp.json()

        if result_data.get("request") == "CAPCHA_NOT_READY":
            time.sleep(5)
            continue

        if result_data.get("status") == 1:
            return result_data["request"]

        raise RuntimeError(f"Polling error: {result_data}")

    raise TimeoutError("GeeTest v3 solve timed out")


# Usage: always fetch a fresh challenge first
PAGE_URL = "https://example.com/login"
gt, challenge = get_fresh_challenge(PAGE_URL)
result = solve_geetest_v3(API_KEY, gt, challenge, PAGE_URL)
print(f"Result: {result}")

# The result contains: challenge, validate, seccode
# Map them to: geetest_challenge, geetest_validate, geetest_seccode

Node.js : terminer la résolution de GeeTest v3 avec un nouveau défi

const API_KEY = "YOUR_CAPTCHAAI_API_KEY";
const SUBMIT_URL = "https://ocr.captchaai.com/in.php";
const RESULT_URL = "https://ocr.captchaai.com/res.php";

function sleep(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

async function getFreshChallenge(targetUrl) {
  const resp = await fetch(`${targetUrl}/api/geetest/register`);
  const data = await resp.json();
  return { gt: data.gt, challenge: data.challenge };
}

async function solveGeetestV3(apiKey, gt, challenge, pageurl) {
  // Submit
  const submitResp = await fetch(SUBMIT_URL, {
    method: "POST",
    headers: { "Content-Type": "application/x-www-form-urlencoded" },
    body: new URLSearchParams({
      key: apiKey,
      method: "geetest",
      gt: gt,
      challenge: challenge,
      pageurl: pageurl,
      json: "1",
    }),
  });

  const submitData = await submitResp.json();
  if (submitData.status !== 1) {
    throw new Error(`Submit failed: ${JSON.stringify(submitData)}`);
  }

  const captchaId = submitData.request;
  console.log(`Task created — captcha ID: ${captchaId}`);

  await sleep(15_000);

  // Poll for result
  for (let i = 0; i < 60; i++) {
    const resultResp = await fetch(
      `${RESULT_URL}?${new URLSearchParams({
        key: apiKey,
        action: "get",
        id: captchaId,
        json: "1",
      })}`
    );

    const resultData = await resultResp.json();

    if (resultData.request === "CAPCHA_NOT_READY") {
      await sleep(5_000);
      continue;
    }

    if (resultData.status === 1) {
      return resultData.request;
    }

    throw new Error(`Polling error: ${JSON.stringify(resultData)}`);
  }

  throw new Error("GeeTest v3 solve timed out");
}

// Usage
const PAGE_URL = "https://example.com/login";

(async () => {
  const { gt, challenge } = await getFreshChallenge(PAGE_URL);
  const result = await solveGeetestV3(API_KEY, gt, challenge, PAGE_URL);
  console.log("Result:", result);
  // Map result fields to: geetest_challenge, geetest_validate, geetest_seccode
})();

FAQ

Pourquoi GeeTest continue-t-il d'échouer même lorsque la requête semble correcte ?

La cause la plus courante est une valeur challenge obsolète. Même si gt et pageurl sont corrects, un défi expiré entraînera l'échec de l'API ou le rejet par la page cible des valeurs renvoyées. Récupérez toujours un nouveau défi immédiatement avant chaque demande de résolution.

Quelle est l’erreur GeeTest v3 la plus courante ?

Réutilisation d'une valeur challenge qui n'est plus fraîche. Les documents CaptchaAI avertissent explicitement qu'une fois le captcha chargé sur la page, l'ancien défi devient invalide.

Que signifie CAPCHA_NOT_READY ?

Cela signifie que la résolution est toujours en cours – il ne s'agit pas d'une erreur. Attendez 5 secondes et interrogez à nouveau res.php. Les résolutions de GeeTest v3 sur CaptchaAI prennent généralement moins de 12 secondes.

Que dois-je faire si l'API renvoie des valeurs mais que la page les rejette toujours ?

Vérifiez trois choses dans l'ordre :

1. Fraîcheur du défi — Le challenge a-t-il été récupéré immédiatement avant la soumission ?
2. Mappage de champs — geetest_challenge, geetest_validate et geetest_seccode sont-ils correctement mappés aux champs attendus de la page cible ?
3. Structure de la demande : la page cible attend-elle du JSON, des données codées sous forme de formulaire ou un autre format ? Comparez avec le trafic réseau d'une résolution manuelle.

En quoi GeeTest v3 est-il différent de reCAPTCHA v2 ?

GeeTest v3 est un défi puzzle/slider (pas une case à cocher). Il nécessite un paramètre dynamique challenge qui doit être actualisé à chaque résolution. L'API renvoie trois champs de validation (challenge, validate, seccode) au lieu d'un seul jeton. Pour la résolution de reCAPTCHA v2, voirComment résoudre reCAPTCHA v2 à l'aide de l'API.

CaptchaAI prend-il en charge GeeTest v4 ?

Cet article couvre uniquement GeeTest v3. Vérifiez leDocumentation sur l'API CaptchaAIpour les derniers types de captcha pris en charge.

Corrigez votre flux de travail GeeTest

Si votre intégration GeeTest échoue :

1. Vérifiez le défi — Est-il récent ? Récupérez-en un nouveau immédiatement avant chaque résolution.
2. Vérifiez les paramètres — gt, challenge, pageurl doivent tous être corrects.
3. Inspecter le mappage des champs — Les challenge, validate et seccode renvoyés doivent être placés dans les bons champs.
4. Comparez à une résolution manuelle — Utilisez les DevTools du navigateur pour capturer la structure exacte de la requête à partir d'une résolution manuelle GeeTest réussie.

Commencez par leSolveur CaptchaAI GeeTest v3, confirmez vos paramètres par rapport auDocuments sur l'API, et lisComment fonctionne le captcha GeeTest v3si vous avez besoin d'informations sur le déroulement du défi.

Journal d'itération

Brief sur les atouts visuels

Image de héros

• Texte alternatif : Dépannage des erreurs GeeTest v3 par le développeur – diagnostic d'échec de demande, d'interrogation et de validation
• Doit afficher : Contexte de débogage avec étapes de flux d'erreurs et points de défaillance
• Nom du fichier : geetest-v3-errors-troubleshooting-hero.png

Visuel 1 dans l'article

• Placement : Après "Erreurs à l'étape de résultat"
• Type : Arbre de décision
• Texte alternatif : Arbre de décision pour les échecs de GeeTest v3 – erreurs de requête, erreurs d'interrogation et échecs de validation
• Nom du fichier : geetest-v3-error-décision-tree.png

Visuel 2 dans l'article

• Placement : Après les « Échecs de validation de la page cible »
• Type : Diagramme des causes et des solutions
• Texte alternatif : Diagramme montrant les causes courantes de rejet de la page GeeTest v3 et leurs correctifs
• Nom du fichier : geetest-v3-validation-causes-fixes.png

Articles connexes

• Résoudre Geetest V3 Nodejs
• Résolution de Geetest V3 Nodejs Captchaai
• Erreurs et correctifs courants de Captcha d’image de grille