BLS CAPTCHA in Regierungsportalen: Umgangsstrategien

Wer in der DACH-Region einen Visumantrag stellt, landet früher oder später auf einem BLS-Portal – und dort vor einem CAPTCHA, das jeden Buchungs-, Upload- oder Absende-Schritt blockiert. Genau an dieser Stelle bricht die meiste Automatisierung ab. CaptchaAI löst BLS-CAPTCHAs über eine einfache API zuverlässig und mit hoher Erfolgsquote, sodass Terminbuchung, Dokument-Upload und Formularübermittlung in einem durchgehenden Workflow funktionieren.

Der Knackpunkt ist selten die Erkennung des CAPTCHAs selbst, sondern das Zusammenspiel aus Sitzungsverwaltung, CSRF-Token und knappen Zeitfenstern. Dieser Leitfaden zeigt den vollständigen Ablauf – von der Extraktion des Bildes bis zum abgeschlossenen Formular – und die Muster, die Behördenportale in der Praxis erzwingen.

Das Wichtigste vorab

• Der Engpass ist die Sitzung, nicht das CAPTCHA: Cookies, CSRF-Token und Ablauffristen entscheiden über Erfolg oder Abbruch.
• Der Ablauf bleibt konstant: Bild extrahieren, an CaptchaAI übermitteln, Antwort per Polling abholen, Formular in derselben Sitzung absenden.
• Zwei Wege: requests.Session() für klassische Portale, Puppeteer nur dann, wenn das CAPTCHA erst per JavaScript geladen wird.
• Kostenmodell: Abrechnung pro Thread, nicht pro Lösung – für einen einzelnen Terminworkflow genügt der Einstiegstarif.

Sitzungsverwaltung: worauf Behördenportale achten

Bevor Sie eine Zeile Lösungscode schreiben, lohnt der Blick auf den Sitzungsstatus – hier scheitern die meisten Workflows. Behördenportale prüfen ihn streng, und diese fünf Punkte entscheiden in der Praxis über Erfolg oder Abbruch:

Rechtlicher Hinweis: Automatisieren Sie ausschließlich eigene, berechtigte Anträge und beachten Sie die Nutzungsbedingungen des Portals. Sobald personenbezogene Daten im Spiel sind, greift die DSGVO – prüfen Sie Rechtsgrundlage und Datenflüsse eigenständig.

Welche BLS-CAPTCHA-Varianten es gibt

BLS-CAPTCHAs treten in mehreren Formen auf, und die Form entscheidet, wie CaptchaAI die Abfrage verarbeitet:

• Bild-CAPTCHAs mit verzerrtem Text
• Rechenaufgaben (mathematische Ausdrücke)
• benutzerdefinierte Bildauswahl-Aufgaben
• textbasierte Rätsel

Jede Variante erwartet einen passenden instructions-Code, der CaptchaAI mitteilt, wie das CAPTCHA zu lösen ist. Diesen Wert setzen Sie einmal pro CAPTCHA-Typ – der übrige Ablauf bleibt gleich.

Wo BLS-CAPTCHAs in Behördenportalen auftauchen

BLS-CAPTCHAs sitzen an den Engstellen eines Portals – überall dort, wo eine Aktion menschlich abgesichert werden soll:

BLS-CAPTCHA mit CaptchaAI lösen: Schritt für Schritt

Schritt 1: CAPTCHA-Bild und Anweisungen abrufen

import requests
from bs4 import BeautifulSoup
import base64

session = requests.Session()

# Load the portal page
page = session.get("https://portal.example.gov/appointment")
soup = BeautifulSoup(page.text, "html.parser")

# Find the CAPTCHA image
captcha_img = soup.select_one("img#captcha-image, img.captcha")
captcha_url = captcha_img["src"]

# Download the CAPTCHA image
if captcha_url.startswith("data:"):
    # Base64 encoded inline image
    img_data = captcha_url.split(",")[1]
else:
    # URL-referenced image
    img_response = session.get(captcha_url)
    img_data = base64.b64encode(img_response.content).decode()

Das Bild liegt entweder als Base64-Inline-Grafik oder als separate URL vor – dieser Block deckt beide Fälle ab und hält die Sitzung dabei offen.

Schritt 2: An CaptchaAI übermitteln

Der instructions-Wert bleibt für reinen verzerrten Text leer; bei Auswahl- oder Rechenaufgaben beschreibt er kurz die Aufgabe. Danach fragen Sie das Ergebnis per Polling ab:

import time

def solve_bls_captcha(image_base64, instructions=""):
    resp = requests.post("https://ocr.captchaai.com/in.php", data={
        "key": "YOUR_API_KEY",
        "method": "base64",
        "body": image_base64,
        "instructions": instructions,
        "json": 1
    })
    task_id = resp.json()["request"]

    for _ in range(30):
        time.sleep(3)
        result = requests.get("https://ocr.captchaai.com/res.php", params={
            "key": "YOUR_API_KEY",
            "action": "get",
            "id": task_id,
            "json": 1
        })
        data = result.json()
        if data["status"] == 1:
            return data["request"]
    raise TimeoutError("BLS solve timed out")

# Solve
captcha_answer = solve_bls_captcha(img_data)

Das Muster ist bewusst schlicht: Sie reichen das Bild ein, fragen das Ergebnis per Polling ab und erhalten die fertige Lösung zurück – ohne clientseitige Bildverarbeitung.

Schritt 3: Formular absenden

# Find form fields
form_data = {
    "captcha_response": captcha_answer,
    "appointment_type": "visa",
    "location": "embassy-city",
    # ... other form fields
}

# Submit with the same session (cookies preserved)
result = session.post(
    "https://portal.example.gov/appointment/submit",
    data=form_data
)

if "success" in result.text.lower():
    print("Form submitted successfully")

Entscheidend ist, dass das Formular in derselben requests.Session() abgesendet wird, in der Sie das CAPTCHA geholt haben – nur so bleiben Cookies und Session-Kontext erhalten.

Typische Muster in Behördenportalen

Mehrstufige Formulare

Behördenportale führen die Nutzer oft über mehrere Schritte, wobei das CAPTCHA erst ganz am Ende erscheint:

# Step 1: Select service type
session.post(url, data={"service": "passport"})

# Step 2: Fill personal details
session.post(url, data={"name": "...", "dob": "..."})

# Step 3: Select appointment slot
session.post(url, data={"slot": "2026-04-10-09:00"})

# Step 4: Solve CAPTCHA and confirm
captcha_answer = solve_bls_captcha(get_captcha_image(session))
session.post(url, data={"captcha": captcha_answer, "confirm": "true"})

Neues CAPTCHA nach einem Fehlversuch

Ist die Antwort falsch, erzeugt das Portal in der Regel ein frisches CAPTCHA. Holen Sie deshalb bei jedem Versuch ein neues Bild, statt die alte Antwort erneut zu senden:

max_attempts = 3
for attempt in range(max_attempts):
    # Get fresh CAPTCHA for each attempt
    captcha_image = get_captcha_image(session)
    answer = solve_bls_captcha(captcha_image)

    result = session.post(submit_url, data={"captcha": answer})
    if "incorrect" not in result.text.lower():
        break
    print(f"Attempt {attempt + 1} — CAPTCHA refreshed, retrying")

Sitzungen mit Zeitlimit

Behördenportale lassen Sitzungen häufig nach einer festen Dauer ablaufen. Prüfen Sie das Zeitfenster, bevor Sie das CAPTCHA übermitteln:

import time

session_start = time.time()
SESSION_TIMEOUT = 600  # 10 minutes typical

def check_session_valid():
    elapsed = time.time() - session_start
    if elapsed > SESSION_TIMEOUT - 60:  # 1 min safety margin
        print("Session expiring — refresh needed")
        return False
    return True

# Before CAPTCHA submission
if not check_session_valid():
    # Start a fresh session
    session = requests.Session()
    session.get(portal_url)
    session_start = time.time()

Portale mit JavaScript: der Browser-Weg (Puppeteer)

Manche Portale rendern das CAPTCHA erst nach der Ausführung von JavaScript. Dann führt der Weg über einen Headless-Browser, der das Bild aus dem DOM ausliest:

const puppeteer = require('puppeteer');

async function handleBLSPortal() {
  const browser = await puppeteer.launch({ headless: false });
  const page = await browser.newPage();

  await page.goto('https://portal.example.gov/appointment');

  // Wait for CAPTCHA to load
  await page.waitForSelector('img#captcha-image');

  // Get CAPTCHA image as base64
  const imgBase64 = await page.evaluate(() => {
    const img = document.querySelector('img#captcha-image');
    const canvas = document.createElement('canvas');
    canvas.width = img.naturalWidth;
    canvas.height = img.naturalHeight;
    const ctx = canvas.getContext('2d');
    ctx.drawImage(img, 0, 0);
    return canvas.toDataURL('image/png').split(',')[1];
  });

  // Mit CaptchaAI lösen
  const answer = await solveBLSCaptcha(imgBase64);

  // Type the answer
  await page.type('#captcha-input', answer);

  // Submit
  await page.click('#submit-button');

  // Wait for result
  await page.waitForNavigation();
}

Als Faustregel gilt: HTTP-Requests mit requests.Session() sind schneller und ressourcenschonender – greifen Sie nur dann zu Puppeteer, wenn das Portal ohne JavaScript nicht funktioniert.

Was kostet das Lösen? Abrechnung pro Thread

CaptchaAI rechnet pro Thread ab – nicht pro gelöstem CAPTCHA. Ein Thread bearbeitet genau eine Abfrage; sobald sie fertig ist, nimmt er die nächste. Die Tarife starten bei BASIC (15 $/Monat, 5 Threads) mit unbegrenzten Lösungen pro Thread. Für einen einzelnen Terminbuchungs-Workflow reicht der Einstiegstarif; parallelisieren Sie erst, wenn Sie mehrere Portale gleichzeitig bedienen.

Häufige Probleme und ihre Lösung

Häufige Fragen

Ist die Automatisierung von BLS-Portalen rechtlich zulässig?

Das hängt vom Portal und Ihrem Zweck ab. Automatisieren Sie ausschließlich eigene, berechtigte Anträge und beachten Sie die Nutzungsbedingungen des jeweiligen Dienstes. Wenn Sie dabei personenbezogene Daten verarbeiten, greift die DSGVO – prüfen Sie Rechtsgrundlage und Datenflüsse selbst. CaptchaAI löst das CAPTCHA, verantwortet aber nicht Ihren rechtlichen Rahmen.

Wie setze ich den instructions-Parameter richtig?

Der instructions-Wert beschreibt der API, welche Aufgabe im Bild steckt – etwa den anzuzeigenden Text bei einem Bild-CAPTCHA oder die Aufgabenstellung bei einer Auswahl. Setzen Sie ihn pro CAPTCHA-Typ einmal passend; für reinen verzerrten Text genügt oft ein leerer Wert.

Was kostet das Lösen von BLS-CAPTCHAs?

CaptchaAI rechnet Thread-basiert ab, nicht pro einzelnem CAPTCHA. Ein Thread bearbeitet ein CAPTCHA gleichzeitig, danach ist er wieder frei – innerhalb des Tarifs sind die Lösungen unbegrenzt. Für Terminbuchungs-Workflows reicht meist der BASIC-Tarif (15 $/Monat, 5 Threads).

Wie gehe ich mit ablaufenden Sitzungen um?

Behalten Sie das Zeitfenster im Blick und lösen Sie das CAPTCHA erst kurz vor dem Absenden. Prüfen Sie die verbleibende Zeit programmatisch (siehe das Muster oben) und starten Sie bei Bedarf eine frische Sitzung, statt einen abgelaufenen Kontext weiterzuverwenden.

Fazit

BLS-CAPTCHAs sind kein Sonderfall: Bild extrahieren, an CaptchaAI übermitteln, Lösung in derselben Sitzung absenden. Der eigentliche Aufwand steckt im sauberen Session-Handling – wer Cookies, CSRF-Token und Zeitfenster im Griff hat, bringt den restlichen Terminbuchungs-Workflow zuverlässig durch.

Verwandte Leitfäden

• CaptchaAI in wenigen Minuten einrichten
• API-Antwortformate und Fehlercodes
• reCAPTCHA v2 per API lösen