CAPTCHA-Lösung für die Automatisierung mobiler Browser mit CaptchaAI

Mobile Browser-Automatisierung lässt sich gegen reCAPTCHA v2 genauso zuverlässig absichern wie ein Desktop-Workflow: Sie lesen den Sitekey aus, übermitteln ihn an die API, fügen das zurückgegebene Token in das Formularfeld ein und senden ab. Der eigentliche Lösungsschritt läuft über CaptchaAI und ist geräteunabhängig. Der Unterschied steckt nicht im Lösen selbst, sondern im Kontext drumherum – ein 390 Pixel breiter Viewport, ein mobiler User-Agent und reine Touch-Interaktionen. Dieses Tutorial zeigt zwei praktikable Wege: Playwright mit Geräte-Emulation in Python und Selenium mit mobiler Emulation in JavaScript.

Was mobile Browser-Automatisierung beim CAPTCHA-Handling besonders macht

Eine für Mobilgeräte optimierte Seite liefert nicht zwangsläufig dasselbe Markup wie ihre Desktop-Variante. Manche Portale erkennen den User-Agent und schalten je nach Gerät eine andere reCAPTCHA-Konfiguration frei. Für den Solver spielt das keine Rolle – CaptchaAI arbeitet ausschließlich mit sitekey und pageurl –, für Ihre Automatisierung aber sehr wohl. Drei Dinge ändern sich im mobilen Kontext:

• Das Widget kann an einer anderen Stelle im Layout liegen.
• Das .g-recaptcha-Element erscheint unter Umständen später im DOM.
• Das Absenden des Formulars ist an einen Touch-Handler statt an einen klassischen Klick gebunden.

Wer diese drei Punkte im Blick behält, überträgt einen bestehenden Desktop-Ablauf ohne Reibung in den mobilen Kontext.

Praxisszenario: reCAPTCHA v2 im mobilen Checkout

Angenommen, Sie testen den mobilen Bestellabschluss eines DACH-Shops – etwa auf Basis von Shopware oder JTL – und die Bestätigungsseite blendet vor dem Absenden ein reCAPTCHA v2 ein. Die Seite prüft den User-Agent und rendert ausschließlich für mobile Clients ein angepasstes CAPTCHA-Layout. Ihr Ziel: das CAPTCHA lösen und das Formular aus einem echten mobilen Browser-Kontext heraus absenden, damit der Server-seitige Abgleich von User-Agent und Session konsistent bleibt. Genau dafür eignen sich die beiden folgenden Ansätze. Ein Hinweis vorweg: Wenn Sie im Rahmen von Scraping personenbezogene Daten oder IP-Adressen verarbeiten, prüfen Sie Ihre Rechtsgrundlage nach DSGVO – das ist Sorgfaltspflicht des Betreibers, keine Aussage über CaptchaAI.

Ansatz 1: Playwright mit Geräte-Emulation (Python)

Die Geräte-Emulation von Playwright ist der schnellste Einstieg, um mobile Browser samt CAPTCHA-Lösung zu automatisieren – ganz ohne physisches Gerät. Sie laden ein Geräteprofil (hier iPhone 13), extrahieren den Sitekey, lassen CaptchaAI lösen und fügen das Token ein:

# playwright_mobile_captcha.py
import asyncio
import httpx
from playwright.async_api import async_playwright

API_KEY = "YOUR_API_KEY"

async def solve_recaptcha(sitekey: str, pageurl: str) -> str:
    """Submit reCAPTCHA v2 to CaptchaAI and poll for result."""
    async with httpx.AsyncClient(timeout=180) as client:
        # Submit task
        resp = await client.get(
            "https://ocr.captchaai.com/in.php",
            params={
                "key": API_KEY,
                "method": "userrecaptcha",
                "googlekey": sitekey,
                "pageurl": pageurl,
                "json": "1",
            },
        )
        result = resp.json()
        if result["status"] != 1:
            raise Exception(f"Submit failed: {result['request']}")

        task_id = result["request"]

        # Poll for result
        for _ in range(30):
            await asyncio.sleep(5)
            poll = await client.get(
                "https://ocr.captchaai.com/res.php",
                params={
                    "key": API_KEY,
                    "action": "get",
                    "id": task_id,
                    "json": "1",
                },
            )
            poll_result = poll.json()
            if poll_result["status"] == 1:
                return poll_result["request"]
            if poll_result["request"] != "CAPCHA_NOT_READY":
                raise Exception(f"Solve failed: {poll_result['request']}")

        raise Exception("Polling timeout")

async def main():
    async with async_playwright() as p:
        # Launch with iPhone 13 emulation
        iphone = p.devices["iPhone 13"]
        browser = await p.chromium.launch(headless=False)
        context = await browser.new_context(**iphone)
        page = await context.new_page()

        await page.goto("https://example.com/mobile-form")
        await page.wait_for_selector(".g-recaptcha", timeout=10000)

        # Extract sitekey
        sitekey = await page.get_attribute(".g-recaptcha", "data-sitekey")
        pageurl = page.url
        print(f"Found sitekey: {sitekey}")

        # Solve via CaptchaAI
        token = await solve_recaptcha(sitekey, pageurl)
        print(f"Token received: {token[:50]}...")

        # Inject token
        await page.evaluate(f"""
            document.getElementById('g-recaptcha-response').value = '{token}';
            document.getElementById('g-recaptcha-response').style.display = '';
        """)

        # Trigger callback if it exists
        await page.evaluate(f"""
            try {{
                const clients = ___grecaptcha_cfg.clients;
                Object.keys(clients).forEach(k => {{
                    Object.keys(clients[k]).forEach(j => {{
                        if (clients[k][j] && clients[k][j].callback) {{
                            clients[k][j].callback('{token}');
                        }}
                    }});
                }});
            }} catch(e) {{}}
        """)

        # Submit form
        await page.click('button[type="submit"]')
        await page.wait_for_load_state("networkidle")
        print("Form submitted successfully")

        await browser.close()

asyncio.run(main())

Das Geräteprofil setzt Viewport, devicePixelRatio und User-Agent in einem Schritt. Der solve_recaptcha-Helfer übermittelt die Aufgabe an in.php und fragt das Ergebnis alle 5 Sekunden über res.php ab, bis ein Token vorliegt oder das Timeout greift.

Ansatz 2: Selenium mit mobiler Emulation (JavaScript)

Wenn Ihre Test-Pipeline bereits auf Node.js und Selenium läuft, bilden Sie den mobilen Kontext über die Mobile-Emulation des Chrome DevTools Protocol ab. Sie definieren Gerätemetriken und User-Agent explizit und behalten den vertrauten Selenium-Ablauf:

// selenium_mobile_captcha.js
const { Builder, By, until } = require('selenium-webdriver');
const chrome = require('selenium-webdriver/chrome');
const axios = require('axios');

const API_KEY = 'YOUR_API_KEY';

async function solveCaptcha(sitekey, pageurl) {
  // Submit task
  const submitResp = await axios.get('https://ocr.captchaai.com/in.php', {
    params: {
      key: API_KEY,
      method: 'userrecaptcha',
      googlekey: sitekey,
      pageurl: pageurl,
      json: '1',
    },
  });

  if (submitResp.data.status !== 1) {
    throw new Error(`Submit failed: ${submitResp.data.request}`);
  }

  const taskId = submitResp.data.request;

  // Poll for result
  for (let i = 0; i < 30; i++) {
    await new Promise((r) => setTimeout(r, 5000));
    const pollResp = await axios.get('https://ocr.captchaai.com/res.php', {
      params: { key: API_KEY, action: 'get', id: taskId, json: '1' },
    });

    if (pollResp.data.status === 1) return pollResp.data.request;
    if (pollResp.data.request !== 'CAPCHA_NOT_READY') {
      throw new Error(`Solve failed: ${pollResp.data.request}`);
    }
  }
  throw new Error('Polling timeout');
}

async function main() {
  // Configure mobile emulation
  const mobileEmulation = {
    deviceMetrics: { width: 390, height: 844, pixelRatio: 3.0 },
    userAgent:
      'Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X) ' +
      'AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.0 Mobile/15E148 Safari/604.1',
  };

  const options = new chrome.Options();
  options.setMobileEmulation(mobileEmulation);

  const driver = await new Builder()
    .forBrowser('chrome')
    .setChromeOptions(options)
    .build();

  try {
    await driver.get('https://example.com/mobile-form');
    await driver.wait(until.elementLocated(By.css('.g-recaptcha')), 10000);

    // Extract sitekey
    const captchaEl = await driver.findElement(By.css('.g-recaptcha'));
    const sitekey = await captchaEl.getAttribute('data-sitekey');
    const pageurl = await driver.getCurrentUrl();

    console.log(`Sitekey: ${sitekey}`);

    // Solve CAPTCHA
    const token = await solveCaptcha(sitekey, pageurl);
    console.log(`Token: ${token.substring(0, 50)}...`);

    // Inject token
    await driver.executeScript(`
      document.getElementById('g-recaptcha-response').value = arguments[0];
    `, token);

    // Submit form
    await driver.findElement(By.css('button[type="submit"]')).click();
    console.log('Form submitted');
  } finally {
    await driver.quit();
  }
}

main().catch(console.error);

Der Kern bleibt in beiden Ansätzen identisch: Sitekey auslesen, an CaptchaAI übergeben, Token in g-recaptcha-response schreiben und das Formular absenden. Nur die Art, wie der mobile Kontext erzeugt wird, unterscheidet sich.

Emulation oder echtes Gerät – was ist die richtige Wahl?

Für Entwicklung und CI/CD ist Emulation fast immer die bessere Wahl: schnell startbar, ressourcenschonend und in GitLab CI oder GitHub Actions ohne Geräte-Farm reproduzierbar. Echte Geräte über Appium oder Chrome for Android via ADB lohnen sich dann, wenn die Zielseite über die reine Viewport-Größe hinaus prüft – etwa Sensorwerte oder gerätespezifische Rendering-Details. Für die meisten reCAPTCHA-v2-Formulare genügt die Emulation, weil die Lösung ohnehin nur von Sitekey und Page-URL abhängt. Beginnen Sie mit der Emulation und wechseln Sie erst dann auf reale Geräte, wenn ein konkreter Abgleich das erfordert.

Mobil-spezifische Faktoren beim CAPTCHA-Handling

Fehlerbehebung: Token wird erzeugt, aber abgelehnt

Preise: parallele mobile Sessions mit Threads abdecken

Mobile Scraping- und Test-Workflows laufen oft in mehreren Sessions gleichzeitig. CaptchaAI rechnet pro gleichzeitigem Thread ab – nicht pro Lösung. Ein Thread ist ein in Bearbeitung befindliches CAPTCHA; sobald eine Lösung fertig ist, nimmt derselbe Thread die nächste Aufgabe an. Jeder Plan enthält unbegrenzte Lösungen pro Thread, ohne Tageslimit und ohne Aufschlag nach CAPTCHA-Typ. Für den Einstieg orientieren Sie sich an der Zahl gleichzeitiger Solves, nicht am Gerät:

• BASIC (15 $/Monat, 5 Threads) reicht für erste Tests.
• STANDARD (30 $/Monat, 15 Threads) trägt dichteren Parallelbetrieb.
• ADVANCE (90 $/Monat, 50 Threads) deckt viele gleichzeitige mobile Emulationen ab. Die aktuellen Tarife stehen auf captchaai.com/pricing – Preise in US-Dollar.

Häufige Fragen (FAQ)

Wie schnell löst CaptchaAI ein reCAPTCHA v2 im mobilen Kontext?

Genauso schnell wie im Desktop-Kontext, denn für die Lösung zählen nur Sitekey und Page-URL – nicht Viewport oder User-Agent. Die Beispiele fragen das Ergebnis alle 5 Sekunden ab und geben das Token zurück, sobald es bereitsteht.

Warum lehnt die Zielseite ein technisch gültiges Token ab?

Meist wegen inkonsistenter Signale: Der Server erwartet denselben User-Agent und dieselbe Session, in der auch gelöst wurde. Verwenden Sie für das Auslesen des Sitekeys, das Lösen und das Absenden durchgängig denselben mobilen Kontext.

Kann CaptchaAI hCaptcha auf mobilen Seiten lösen?

Nein. hCaptcha und FunCaptcha (Arkose Labs) werden nicht unterstützt. Dieses Tutorial deckt reCAPTCHA v2 ab; darüber hinaus löst CaptchaAI unter anderem reCAPTCHA v3, Cloudflare Turnstile und Challenge, GeeTest v3 sowie Bild- und Raster-CAPTCHAs.

Welcher CaptchaAI-Plan passt für viele parallele mobile Sessions?

Richten Sie sich nach der Zahl gleichzeitiger Solves, nicht nach der Zahl der Geräte. BASIC (15 $/Monat, 5 Threads) genügt für Tests; für dichten Parallelbetrieb sind STANDARD (30 $/Monat, 15 Threads) oder ADVANCE (90 $/Monat, 50 Threads) sinnvoll – jeweils mit unbegrenzten Lösungen pro Thread.

Verwandte Leitfäden

• reCAPTCHA-Handling mit XCUITest unter iOS
• CAPTCHA-Tests mit Android Espresso
• CAPTCHA-Lösung in React-Native-WebViews