Axios + CaptchaAI: CAPTCHAs ohne Browser lösen

Ja – Sie können reCAPTCHA, Cloudflare Turnstile und Bild-CAPTCHAs vollständig ohne Browser lösen. Ein Headless-Browser belegt pro Instanz 200–500 MB RAM; auf einem Node.js-Worker, der eigentlich nur ein Token benötigt, ist das verschwendete Rechenleistung. Mit Axios und CaptchaAI genügen reine HTTP-Anfragen: Sie übermitteln die CAPTCHA-Parameter an die API, fragen das Ergebnis ab und tragen das fertige Token in Ihr Formular ein – kein Chromium im Hintergrund, kein Rendering, keine Zombie-Prozesse.

Genau dieser Ansatz eignet sich für serverseitige Automatisierung: Cron-Jobs, Scraping-Worker oder API-Integrationen, die auf einem kleinen VPS bei Hetzner oder netcup laufen sollen, ohne dass Sie für jede Anfrage eine ganze Browser-Instanz starten.

Der zweite Vorteil ist die Betriebsstabilität. Headless-Chromium bringt in Docker-Images schnell 300 MB an Systembibliotheken mit und neigt bei hoher Last zu abgestürzten Prozessen, die belegten Speicher nicht freigeben. Ein reiner HTTP-Client hat keine dieser Abhängigkeiten: Das Image bleibt schlank, der Container startet in Millisekunden, und die gleiche Logik läuft unverändert in einer GitLab-CI-Pipeline wie auf dem Produktions-Worker.

Voraussetzungen

npm install axios

Der CaptchaAI-Client in Node.js

Die folgende Klasse kapselt den kompletten Ablauf: submit schickt die Aufgabe an in.php, poll fragt res.php im Fünf-Sekunden-Takt ab, bis das Token bereitsteht, und solve fasst beide Schritte zusammen. Mehr Logik brauchen Sie für den Einstieg nicht. Über das Standard-Timeout von 300 Sekunden bricht der Poll-Vorgang kontrolliert ab, statt endlos zu warten – für Batch-Jobs können Sie den Wert nach unten setzen. Die zusätzliche Methode getBalance liefert Ihr aktuelles Guthaben zurück und eignet sich gut als kleiner Health-Check, bevor ein Worker eine größere Stapelverarbeitung startet.

const axios = require("axios");

class CaptchaAI {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = "https://ocr.captchaai.com";
  }

  async submit(params) {
    params.key = this.apiKey;
    const resp = await axios.get(`${this.baseUrl}/in.php`, { params });
    const text = resp.data;

    if (!String(text).startsWith("OK|")) {
      throw new Error(`Submit failed: ${text}`);
    }
    return String(text).split("|")[1];
  }

  async poll(taskId, timeoutMs = 300000) {
    const deadline = Date.now() + timeoutMs;
    const params = { key: this.apiKey, action: "get", id: taskId };

    while (Date.now() < deadline) {
      await new Promise((r) => setTimeout(r, 5000));

      const resp = await axios.get(`${this.baseUrl}/res.php`, { params });
      const text = String(resp.data);

      if (text === "CAPCHA_NOT_READY") continue;
      if (text.startsWith("OK|")) return text.split("|").slice(1).join("|");
      throw new Error(`Solve failed: ${text}`);
    }
    throw new Error(`Timeout after ${timeoutMs}ms for task ${taskId}`);
  }

  async solve(params, timeoutMs = 300000) {
    const taskId = await this.submit(params);
    return this.poll(taskId, timeoutMs);
  }

  async getBalance() {
    const resp = await axios.get(`${this.baseUrl}/res.php`, {
      params: { key: this.apiKey, action: "getbalance" },
    });
    return parseFloat(resp.data);
  }
}

module.exports = CaptchaAI;

reCAPTCHA v2 ohne Browser lösen

Für reCAPTCHA v2 brauchen Sie nur zwei Werte aus der Zielseite: den googlekey (den Sitekey aus dem data-sitekey-Attribut) und die pageurl. CaptchaAI liefert das gelöste Token zurück, das Sie als g-recaptcha-response mit dem Formular absenden.

const CaptchaAI = require("./captchaai");

async function main() {
  const solver = new CaptchaAI(process.env.CAPTCHAAI_API_KEY);

  // Solve the CAPTCHA without opening any browser
  const token = await solver.solve({
    method: "userrecaptcha",
    googlekey: "6Le-wvkS...",
    pageurl: "https://example.com/login",
  });

  // Submit form with the token using Axios
  const resp = await axios.post("https://example.com/login", {
    username: "user",
    password: "pass",
    "g-recaptcha-response": token,
  });

  console.log(`Login response: ${resp.status}`);
}

main().catch(console.error);

Cloudflare Turnstile per HTTP lösen

Turnstile funktioniert nach demselben Muster – nur heißt der Parameter sitekey und das Antwortfeld cf-turnstile-response. Turnstile wird dabei typischerweise in unter 10 Sekunden gelöst.

const token = await solver.solve({
  method: "turnstile",
  sitekey: "0x4AAAAA...",
  pageurl: "https://example.com",
});

// Submit with Turnstile token
const resp = await axios.post("https://example.com/api/verify", {
  "cf-turnstile-response": token,
  data: "payload",
});

Bild-CAPTCHAs (OCR) lösen

Klassische Bild-CAPTCHAs schicken Sie base64-kodiert an die API. Zurück kommt der erkannte Text, den Sie direkt in das entsprechende Formularfeld eintragen.

const fs = require("fs");

const imageBuffer = fs.readFileSync("captcha.png");
const imageB64 = imageBuffer.toString("base64");

const text = await solver.solve({
  method: "base64",
  body: imageB64,
});

console.log(`CAPTCHA text: ${text}`);

// Submit form with solved text
const resp = await axios.post("https://example.com/verify", {
  captcha: text,
  other_data: "value",
});

Scraping-Workflow ohne Browser

In der Praxis kombinieren Sie den Solver mit cheerio, um Sitekey und Formularfelder direkt aus dem HTML zu lesen. Der folgende Ablauf holt die Seite, extrahiert den reCAPTCHA-Sitekey, lässt CaptchaAI lösen und sendet das Formular zurück – alles über HTTP.

Ein Hinweis zur DSGVO: IP-Adressen und viele gescrapte Inhalte gelten als personenbezogene Daten. Prüfen Sie vor produktivem Einsatz Ihre Rechtsgrundlage und die Nutzungsbedingungen der Zielseite.

const CaptchaAI = require("./captchaai");
const axios = require("axios");
const cheerio = require("cheerio");

async function scrapeProtectedPage(url) {
  const solver = new CaptchaAI(process.env.CAPTCHAAI_API_KEY);

  // Step 1: Fetch the page
  const page = await axios.get(url);
  const $ = cheerio.load(page.data);

  // Step 2: Extract the reCAPTCHA site key
  const siteKey = $(".g-recaptcha").attr("data-sitekey");
  if (!siteKey) {
    console.log("No CAPTCHA found, returning page content");
    return page.data;
  }

  // Step 3: Solve the CAPTCHA
  console.log(`Solving CAPTCHA for ${url}...`);
  const token = await solver.solve({
    method: "userrecaptcha",
    googlekey: siteKey,
    pageurl: url,
  });

  // Step 4: Submit form with token
  const formAction = $("form").attr("action") || url;
  const formData = {};

  $("form input").each((_, el) => {
    const name = $(el).attr("name");
    const value = $(el).attr("value") || "";
    if (name) formData[name] = value;
  });
  formData["g-recaptcha-response"] = token;

  const result = await axios.post(formAction, new URLSearchParams(formData), {
    headers: { "Content-Type": "application/x-www-form-urlencoded" },
  });

  return result.data;
}

scrapeProtectedPage("https://example.com/data")
  .then((data) => console.log("Success:", typeof data))
  .catch(console.error);

Mehrere CAPTCHAs parallel lösen

Da kein Browser die Ressourcen frisst, können Sie viele CAPTCHAs gleichzeitig über Promise.all verarbeiten. Wie viele parallel laufen, bestimmt Ihre Thread-Zahl: CaptchaAI rechnet Thread-basiert ab – ein Thread ist ein gleichzeitig laufendes CAPTCHA, und jeder Tarif enthält unbegrenzte Lösungen je Thread. Der BASIC-Tarif (15 $/Monat, 5 Threads) deckt fünf parallele Aufgaben ab; wer mehr Durchsatz braucht, wählt etwa ADVANCE (90 $/Monat, 50 Threads).

async function solveBatch(urls, siteKey) {
  const solver = new CaptchaAI(process.env.CAPTCHAAI_API_KEY);

  const promises = urls.map(async (url) => {
    try {
      const token = await solver.solve({
        method: "userrecaptcha",
        googlekey: siteKey,
        pageurl: url,
      });
      return { url, token, error: null };
    } catch (error) {
      return { url, token: null, error: error.message };
    }
  });

  const results = await Promise.all(promises);

  const solved = results.filter((r) => r.token);
  console.log(`Solved ${solved.length}/${urls.length}`);
  return results;
}

Fehler und Fehlerbehebung

Häufige Fragen

Welche CAPTCHA-Typen kann ich per HTTP lösen?

reCAPTCHA v2 und v3 (inkl. Enterprise), Cloudflare Turnstile und Challenge, GeeTest v3 sowie Bild- und Raster-CAPTCHAs – alle über dieselbe in.php/res.php-Schnittstelle. CaptchaFox, Friendly Captcha und Lemin sind aktuell in Beta. hCaptcha und FunCaptcha werden nicht unterstützt.

Was kostet das Lösen von CAPTCHAs?

CaptchaAI rechnet pro Thread ab – nicht pro Lösung. Jeder Plan enthält unbegrenzte Lösungen pro Thread, ohne Tageslimits oder Aufschläge je CAPTCHA-Typ. Der Einstieg beginnt bei 15 $/Monat (BASIC, 5 Threads).

Wie lange ist ein gelöstes Token gültig?

reCAPTCHA- und Turnstile-Tokens laufen typischerweise nach rund 120 Sekunden ab. Senden Sie das Token deshalb unmittelbar nach dem Lösen ab und speichern Sie es nicht auf Vorrat.

Kann ich statt Axios das native fetch nutzen?

Ja. Node.js 18+ bringt ein eingebautes fetch mit; die CaptchaAI-Parameter bleiben identisch. Axios ist nur etwas bequemer bei Query-Parametern und beim Auswerten von Fehlern.

Wann brauche ich trotzdem noch einen Browser?

Nur, wenn die Zielseite ihre Inhalte per JavaScript rendert und Sie dieses gerenderte DOM benötigen. Für das reine CAPTCHA-Lösen ist ein Browser nie nötig – das übernimmt CaptchaAI aus der Ferne.

Weiterführende Guides

• CAPTCHA-Scraping mit Node.js
• HTTPX + CaptchaAI integrieren
• CAPTCHAs per cURL lösen