Résoudre plusieurs CAPTCHA en Python et Node.js

Utilisez Python 3.10+ ou Node.js 22+. Installez le SDK officiel à partir de l’URL de téléchargement indiquée dans la documentation ; utilisez le téléchargement direct du paquet. Conservez la clé API de l’espace de travail sur le serveur.

• Définissez SOLVETHREE_API_KEY et SOLVETHREE_PROXY dans l’environnement du serveur.
• Remplacez accounts.example.com et login par le nom d’hôte et l’action de votre cible. Le site doit déjà disposer d’un profil actif accessible à votre espace de travail ; soumettre un nom d’hôte ne crée pas de profil.
• Traitez chaque entrée de jobs comme une tâche logique distincte. Les exemples répètent le même site, la même action et le même proxy pour garder le lot lisible, mais attribuent un requestId distinct à chaque tâche.
• Conservez les données de chaque tâche inchangées pendant la récupération. Une nouvelle résolution indépendante nécessite un nouvel identifiant ; la récupération d’une résolution interrompue nécessite l’identifiant d’origine et des données identiques.

import os
from concurrent.futures import ThreadPoolExecutor, as_completed
from uuid import uuid4
from solvethree import Solvethree

# Each worker gets its own synchronous client.
def solve_one(job):
    client = Solvethree(os.environ["SOLVETHREE_API_KEY"])
    return client.solve({**job, "requestId": str(uuid4())}, timeout=180)

jobs = [
    {"site": "accounts.example.com", "action": "login", "proxy": os.environ["SOLVETHREE_PROXY"]}
    for _ in range(8)
]
with ThreadPoolExecutor(max_workers=4) as pool:
    futures = [pool.submit(solve_one, job) for job in jobs]
    for future in as_completed(futures):
        try:
            result = future.result()
            print("Ready task:", result["id"])
            # Submit this solution promptly; don't wait for the whole batch.
        except Exception as error:
            print("One task failed:", type(error).__name__)

import { randomUUID } from 'node:crypto';
import { Solvethree } from '@solvethree/sdk';

const client = new Solvethree({ apiKey: process.env.SOLVETHREE_API_KEY });
const jobs = Array.from({ length: 8 }, () => ({
  site: 'accounts.example.com', action: 'login',
  proxy: process.env.SOLVETHREE_PROXY, requestId: randomUUID(),
}));
let next = 0;
async function worker() {
  while (next < jobs.length) {
    const job = jobs[next++];
    try {
      const result = await client.solve(job, { timeoutMs: 180_000 });
      console.log('Ready task:', result.id);
      // Submit this solution promptly, before taking another job.
    } catch (error) {
      console.error('One task failed:', error.constructor.name);
    }
  }
}
await Promise.all(Array.from({ length: Math.min(4, jobs.length) }, worker));

Python a besoin de threads ici, car `Solvethree` est synchrone. Chaque appel à solve crée une tâche et attend un résultat prêt ou lève une exception. Il n’existe pas de client asynchrone natif : l’appeler directement dans une fonction asynchrone bloquerait donc toujours le thread de la boucle d’événements de cette fonction. L’exemple utilise quatre workers dans un pool de threads, chacun avec son propre client, et traite les futures terminées sans attendre l’ensemble du lot.

Node.js limite la concurrence à l’aide de quatre promesses de workers. Chaque worker attend la fin d’une résolution avant de prendre une autre tâche. Promise.all attend ces workers ; il ne lance pas toutes les tâches en même temps. À l’inverse, appliquer directement des appels à solve à une liste de tâches non bornée lance immédiatement toute la liste et ne fournit aucune limite de concurrence utile.

Les deux exemples interceptent les erreurs pour chaque tâche afin qu’une résolution échouée n’arrête pas les tâches restantes. Le délai d’attente de 180 secondes s’applique à chaque appel à solve, pas à l’ensemble du lot.

Remplacez le commentaire du chemin de réussite par votre soumission à la cible avant d’exécuter un lot réel. L’identifiant affiché identifie la tâche ; ce n’est pas le jeton reCAPTCHA. Soumettez solution.token avec les valeurs userAgent et secChUa renvoyées, en utilisant le même proxy que celui fourni pour cette tâche.

N’accumulez pas tous les jetons en attendant la résolution la plus lente avant de les utiliser. Traitez chaque résultat prêt dès qu’il arrive. Le SDK résout le CAPTCHA ; il ne soumet pas la solution à votre cible, et une tâche prête ne prouve pas que la cible a accepté la requête suivante.

Les exemples affichent les noms des classes d’erreurs pour garder le modèle de workers concis. Dans une intégration, conservez la tâche concernée et les identifiants de récupération exposés par les erreurs du SDK : Python utilise request_id et task_id ; JavaScript utilise requestId et taskId.

Une résolution dépasse son délai d’attente ou perd sa connexion.

Vérifiez si l’erreur contient un identifiant de tâche ou de requête. La tâche distante peut toujours exister.

Essayez ceci : Reprenez l’interrogation périodique par GET lorsque vous connaissez l’identifiant de la tâche. Sinon, récupérez la création en renvoyant des données identiques avec le même identifiant de requête.

Le SDK lève TaskFailedError.

Examinez errorCode et error de la tâche arrivée à un état final.

Essayez ceci : Arrêtez d’interroger cette tâche et corrigez la cause signalée avant de lancer une autre résolution. Ne renvoyez pas aveuglément des données invalides inchangées.

Réexécuter l’un ou l’autre exemple génère de nouveaux identifiants de requête et lance de nouvelles tâches logiques ; ce n’est pas une récupération. Les deux SDK évitent de relancer automatiquement la création des tâches : conservez donc suffisamment d’informations pour récupérer uniquement la tâche interrompue plutôt que de soumettre à nouveau un travail déjà réussi.