BLS CAPTCHA vs. reCAPTCHA Grid

Optisch ähneln sich beide – Sie wählen Bilder nach einer Textvorgabe aus. Der praktische Unterschied liegt aber nicht im Aussehen, sondern in der Integration: reCAPTCHA Grid liefert am Ende ein fertiges Token, das Sie in ein Formularfeld schreiben. BLS CAPTCHA verlangt dagegen echte Handarbeit im DOM – jedes Bild extrahieren, als Base64 kodieren und die richtigen Kacheln per Index anklicken. Daraus folgen zwei grundverschiedene Wege und in CaptchaAI zwei getrennte API-Methoden: method=bls und method=userrecaptcha.

Wo Ihnen die beiden Typen begegnen

BLS CAPTCHA ist keine Standardkomponente, sondern eine proprietäre Implementierung von BLS International – für viele DACH-Anwender ein vertrautes Nadelöhr. reCAPTCHA hingegen ist Googles global ausgerolltes System. Grob teilt sich die Praxis so auf:

• BLS CAPTCHA: fast ausschließlich auf den Visa-Terminportalen, über die BLS die Terminvergabe für zahlreiche Auslandsvertretungen abwickelt.
• reCAPTCHA Grid: auf Millionen Seiten weltweit, vom Login über Formulare bis zum Checkout.

Wer Terminbuchungen automatisiert, trifft daher meist auf BLS CAPTCHA; wer Formulare oder Scraping absichert, fast immer auf reCAPTCHA Grid. Einige BLS-Portale kombinieren sogar beides.

BLS CAPTCHA und reCAPTCHA Grid im direkten Vergleich

Welche Methode wann?

Die Wahl hängt nicht von Vorlieben ab, sondern davon, was die Zielseite ausliefert:

• BLS-Visumtermin buchen: method=bls mit Bildextraktion.
• Beliebige Seite mit reCAPTCHA: method=userrecaptcha mit Sitekey.
• BLS-Seite mit eingebettetem reCAPTCHA: prüfen, welcher Typ die jeweilige Aktion schützt – BLS-Portale nutzen teils beide.
• Unbekanntes Bild-CAPTCHA: zuerst auf BLS-Branding prüfen; sonst reCAPTCHA- oder OCR-Methode testen.

Praxisbeispiel: Auf einem BLS-Terminportal sichert das proprietäre Bild-CAPTCHA oft die erste Verifikation, während ein reCAPTCHA v2 das Absenden des Formulars schützt. Erkennen Sie dann beide Typen getrennt und rufen Sie für jeden die passende CaptchaAI-Methode auf.

BLS CAPTCHA mit CaptchaAI lösen

Der Ablauf ist bildzentriert und gliedert sich in drei Schritte:

• Anweisungstext auslesen und jedes Bild als Base64 kodieren.
• Alles gemeinsam an CaptchaAI übermitteln und das Ergebnis abfragen.
• Die zurückgegebenen Indizes der passenden Bilder im Browser anklicken.

Python:

import requests
import base64
import time
from selenium import webdriver
from selenium.webdriver.common.by import By

driver = webdriver.Chrome()
driver.get("https://example-bls-site.com/appointment")

# Step 1: Extract instruction text
instruction = driver.find_element(By.CSS_SELECTOR, ".captcha-instruction").text
# Example: "Select all images with a motorcycle"

# Step 2: Extract and encode each image
images = driver.find_elements(By.CSS_SELECTOR, ".captcha-image img")
image_data = {}
for i, img in enumerate(images, 1):
    # Get image source and convert to base64
    src = img.get_attribute("src")
    if src.startswith("data:image"):
        b64 = src.split(",")[1]
    else:
        img_bytes = requests.get(src).content
        b64 = base64.b64encode(img_bytes).decode()
    image_data[f"image_base64_{i}"] = b64

# Step 3: Submit to CaptchaAI
payload = {
    "key": "YOUR_API_KEY",
    "method": "bls",
    "instructions": instruction,
    **image_data
}
resp = requests.post("https://ocr.captchaai.com/in.php", data=payload)
task_id = resp.text.split("|")[1]

# Step 4: Poll for result
for _ in range(30):
    time.sleep(5)
    result = requests.get("https://ocr.captchaai.com/res.php", params={
        "key": "YOUR_API_KEY", "action": "get", "id": task_id
    })
    if result.text.startswith("OK|"):
        indices = result.text.split("|")[1]  # e.g., "1,3,5"
        break

# Step 5: Click the correct images
for idx in indices.split(","):
    images[int(idx) - 1].click()
    time.sleep(0.3)  # Small delay between clicks

Node.js:

const axios = require("axios");
const puppeteer = require("puppeteer");

(async () => {
  const browser = await puppeteer.launch({ headless: "new" });
  const page = await browser.newPage();
  await page.goto("https://example-bls-site.com/appointment");

  // Extract instruction text
  const instruction = await page.$eval(
    ".captcha-instruction",
    (el) => el.textContent,
  );

  // Extract images as base64
  const imageElements = await page.$$(".captcha-image img");
  const imageData = {};
  for (let i = 0; i < imageElements.length; i++) {
    const src = await imageElements[i].evaluate((el) => el.src);
    let b64;
    if (src.startsWith("data:image")) {
      b64 = src.split(",")[1];
    } else {
      const resp = await axios.get(src, { responseType: "arraybuffer" });
      b64 = Buffer.from(resp.data).toString("base64");
    }
    imageData[`image_base64_${i + 1}`] = b64;
  }

  // Submit to CaptchaAI
  const formData = new URLSearchParams({
    key: "YOUR_API_KEY",
    method: "bls",
    instructions: instruction,
    ...imageData,
  });
  const submitResp = await axios.post(
    "https://ocr.captchaai.com/in.php",
    formData.toString(),
  );
  const taskId = submitResp.data.split("|")[1];

  // Poll for result
  let indices;
  for (let i = 0; i < 30; i++) {
    await new Promise((r) => setTimeout(r, 5000));
    const result = await axios.get("https://ocr.captchaai.com/res.php", {
      params: { key: "YOUR_API_KEY", action: "get", id: taskId },
    });
    if (result.data.startsWith("OK|")) {
      indices = result.data.split("|")[1];
      break;
    }
  }

  // Click correct images
  for (const idx of indices.split(",")) {
    await imageElements[parseInt(idx) - 1].click();
    await new Promise((r) => setTimeout(r, 300));
  }

  await browser.close();
})();

reCAPTCHA Grid mit CaptchaAI lösen

Hier entfällt die gesamte Bildarbeit. Sie lesen nur den Sitekey aus dem g-recaptcha-Element und die Page-URL aus und schicken beides an CaptchaAI. Zurück kommt ein fertiges Token, das Sie in das Feld g-recaptcha-response schreiben oder direkt per HTTP POST absenden – ganz ohne Browser.

Python:

import requests
import time

# Step 1: Extract sitekey from page
# <div class="g-recaptcha" data-sitekey="6Le-wvkS..."></div>
sitekey = "6Le-wvkSAAAAAPBMRTvw..."
page_url = "https://example.com/form"

# Step 2: Submit to CaptchaAI
resp = requests.get("https://ocr.captchaai.com/in.php", params={
    "key": "YOUR_API_KEY",
    "method": "userrecaptcha",
    "googlekey": sitekey,
    "pageurl": page_url
})
task_id = resp.text.split("|")[1]

# Step 3: Poll for token
for _ in range(60):
    time.sleep(5)
    result = requests.get("https://ocr.captchaai.com/res.php", params={
        "key": "YOUR_API_KEY", "action": "get", "id": task_id
    })
    if result.text.startswith("OK|"):
        token = result.text.split("|")[1]
        break

# Step 4: Inject token (no clicking needed)
# Option A: Hidden field injection
driver.execute_script(
    f'document.getElementById("g-recaptcha-response").value = "{token}";'
)
# Option B: Pure HTTP submission
requests.post(page_url, data={"g-recaptcha-response": token, "other_field": "value"})

Node.js:

const axios = require("axios");

async function solveRecaptchaGrid(sitekey, pageUrl) {
  // Submit
  const submitResp = await axios.get("https://ocr.captchaai.com/in.php", {
    params: {
      key: "YOUR_API_KEY",
      method: "userrecaptcha",
      googlekey: sitekey,
      pageurl: pageUrl,
    },
  });
  const taskId = submitResp.data.split("|")[1];

  // Poll for token
  for (let i = 0; i < 60; i++) {
    await new Promise((r) => setTimeout(r, 5000));
    const result = await axios.get("https://ocr.captchaai.com/res.php", {
      params: { key: "YOUR_API_KEY", action: "get", id: taskId },
    });
    if (result.data.startsWith("OK|")) {
      return result.data.split("|")[1];
    }
  }
  throw new Error("Solve timed out");
}

Integrationsaufwand im Vergleich

Der reine Codeumfang macht den Unterschied greifbar – die Token-Methode ist in wenigen Zeilen erledigt, BLS übernimmt jeden Schritt der Bildpipeline selbst:

• Bildextraktion: BLS holt jedes Bild manuell aus dem DOM; bei reCAPTCHA erledigt die Token-Methode das intern.
• Anweisungstext und Base64-Kodierung: bei BLS für jedes Bild Pflicht, bei reCAPTCHA entfällt beides.
• Lösung anwenden: BLS klickt einzelne Bilder per zurückgegebenem Index an; reCAPTCHA fügt das Token in ein verstecktes Feld oder per HTTP POST ein.
• Browser-Automatisierung: bei BLS zwingend, bei reCAPTCHA optional – reine HTTP-Anfragen genügen.
• Paralleles Lösen: bei BLS an die Browser-Sitzung gebunden, bei reCAPTCHA zustandslos und dadurch einfach zu skalieren.
• Typischer Codeumfang: BLS 40–60 Zeilen, reCAPTCHA Grid 15–25 Zeilen.

Häufige Fehler beheben

Die meisten Fehlerbilder lassen sich einem der beiden Wege zuordnen – prüfen Sie zuerst, welcher Typ die Abfrage stellt.

Bei BLS CAPTCHA

• Falsche Antwort zurückgegeben: prüfen, ob der Anweisungstext exakt dem auf der Seite entspricht.
• Bilder laden nicht: beim Abruf der Bild-URLs User-Agent und Cookies mitsenden.
• Antwort abgelehnt: Indizes in der richtigen Reihenfolge auf der Seite anklicken.
• Lösen dauert zu lange: Bildanzahl reduzieren und nur sichtbare Bilder senden.

Bei reCAPTCHA Grid

• Falsches Ergebnis: Sitekey und Page-URL auf Korrektheit prüfen.
• Token abgelehnt: in g-recaptcha-response einfügen und zusätzlich den Callback ausführen.
• Lösen dauert zu lange: einen Proxy nahe der Zielseite verwenden.

Häufige Fragen

Woran erkenne ich, ob eine Seite BLS CAPTCHA oder reCAPTCHA einsetzt?

Am schnellsten über das Seiten-Markup. Ein div mit der Klasse g-recaptcha und einem data-sitekey-Attribut weist auf reCAPTCHA hin. BLS-Portale liefern stattdessen einen festen Satz separater Bilder samt Anweisungstext, ganz ohne Sitekey.

Wie viele Threads brauche ich für parallele BLS-Terminbuchungen?

So viele, wie Sie gleichzeitig laufende Vorgänge erwarten. CaptchaAI rechnet pro Thread ab, nicht pro Lösung – ein Thread ist eine gleichzeitig in Bearbeitung befindliche CAPTCHA-Abfrage. BASIC (15 $/Monat, 5 Threads) deckt geringe Parallelität ab, STANDARD (30 $/Monat, 15 Threads) mehr. Da BLS pro Lösung eine Browser-Sitzung bindet, begrenzt hier eher Ihre eigene Infrastruktur als die Threadzahl.

Wie lange ist ein reCAPTCHA-Token gültig?

In der Regel rund 120 Sekunden. Fordern Sie das Token daher erst an, wenn Sie es unmittelbar absenden können, statt es vorzuhalten. Läuft es ab, genügt ein weiterer Aufruf von method=userrecaptcha.

Löst CaptchaAI hCaptcha, falls ein Portal darauf umstellt?

Nein. CaptchaAI unterstützt hCaptcha derzeit nicht – ebenso wenig FunCaptcha oder GeeTest v4. Verfügbar sind unter anderem reCAPTCHA v2/v3, Cloudflare Turnstile und Challenge, GeeTest v3 sowie OCR-, Raster- und BLS-CAPTCHAs.

Verwandte Leitfäden

• BLS CAPTCHA Schritt für Schritt lösen – vollständige Anleitung zur BLS-Integration
• reCAPTCHA v2 per API lösen – komplettes reCAPTCHA-v2-Tutorial
• Rasterbild-CAPTCHAs automatisch lösen – wie Raster-Abfragen funktionieren
• BLS-CAPTCHA-Fehler beheben – BLS-spezifische Fehlerbehebungen