Fallstudie7 Min. Lesezeit

Account-Registrierung über 50 Profile skalieren: ein echter Batch-Workflow

Ein Team kombinierte eindeutige Profildaten, automatische CAPTCHA-Lösung und Recovery-Prüfungen, um einen Registrierungs-Run über 50 Browser durchgängig konsistent zu halten.

8. März 2026

Das Szenario

Ein Team musste Konten auf einer Plattform über 50 Antidetekt-Browser-Profile registrieren. Jedes Konto erforderte eine eindeutige E-Mail, einen Namen, eine Telefonnummer und ein Passwort. Der Registrierungsfluss umfasste E-Mail-Verifizierung, eine reCAPTCHA v2-Herausforderung und einen Onboarding-Schritt nach der Registrierung.

Dies manuell zu tun würde 3-4 Stunden dauern. Mit Ornold MCP und einem KI-Agenten wurde der gesamte Batch in weniger als 25 Minuten abgeschlossen — einschließlich CAPTCHA-Lösung und Fehlerwiederherstellung.

Vorbereitung: Daten pro Profil

Der erste Schritt war die Vorbereitung eindeutiger Daten für jedes der 50 Profile. Jedes Feld, das das Registrierungsformular erforderte, benötigte einen unterschiedlichen Wert pro Sitzung. Die Wiederverwendung von Daten über Profile hinweg ist der schnellste Weg, um gekennzeichnet zu werden.

Das Team bereitete einen Datensatz mit vor:

Eindeutige E-Mail-Adressen (eine pro Profil, von verschiedenen Anbietern)
Realistische Namen, die den Gebietsschema-/Spracheinstellungen des Profils entsprechen
Starke Passwörter (eindeutig pro Profil, nicht sequenziell)
Telefonnummern zur SMS-Verifizierung (von einem virtuellen Nummernservice)

Datenqualität ist wichtiger als Automatisierungsgeschwindigkeit. Eine doppelte E-Mail oder ein offensichtlich gefälschter Name können Betrugserkennung auslösen und den gesamten Batch kennzeichnen. Investieren Sie Zeit in die Erstellung realistischer, vielfältiger Datensätze.

// Beispiel-Profilddatensatz-Struktur
const profiles = [
  { email: "sarah.mitchell@proton.me", name: "Sarah Mitchell", phone: "+1-555-0142", password: "kR9#mPx2vL" },
  { email: "james.wong@tutanota.com", name: "James Wong", phone: "+1-555-0198", password: "nT4$hQw8bJ" },
  // ... 48 weitere eindeutige Profile
];

Phase 1: Start und Navigation

Mit 50 bereiten Linken Sphere-Sitzungen (jede mit eigenem Proxy, Fingerabdruck und Zeitzone) war der erste Schritt, alle gleichzeitig zur Registrierungsseite zu navigieren.

// Alle Sitzungen starten und zur Registrierungsseite navigieren
await browser_list(); // Überprüfen, dass 50 Sitzungen verfügbar sind
await browser_parallel_navigate({ url: "https://target.example/signup" });

// Warten, bis das Formular in allen Sitzungen geladen ist
await browser_parallel_wait_for({
  text: "Create your account",
  timeoutMs: 20000
});

48 von 50 Sitzungen luden die Registrierungsseite innerhalb von 8 Sekunden. Zwei Sitzungen waren aufgrund von Proxy-Latenz langsamer — der `wait_for`-Befehl wartete, bis sie die 14-Sekunden-Marke erreichten.

Phase 2: Formularausfüllung

Jede Sitzung benötigte ihre eigenen eindeutigen Daten. Der parallele Ausfüllbefehl von Ornold akzeptiert ein Array von Werten, das 1:1 zu aktiven Sitzungen zugeordnet wird:

// E-Mail ausfüllen — jede Sitzung erhält einen eindeutigen Wert
await browser_parallel_fill({
  ref: "email",
  values: profiles.map(p => p.email)
});

// Namen ausfüllen
await browser_parallel_fill({
  ref: "fullname",
  values: profiles.map(p => p.name)
});

// Passwort ausfüllen
await browser_parallel_fill({
  ref: "password",
  values: profiles.map(p => p.password)
});

Das Ausfüllen des Formulars über alle 50 Sitzungen dauerte etwa 3 Sekunden. Der DOM-basierte Interaktionsmodus (kostenlos, keine Vision-Credits) handhabte die strukturierten Formularfelder problemlos.

Phase 3: CAPTCHA-Lösung

Die Registrierungsseite hatte eine reCAPTCHA v2-Herausforderung. Ornold erkannte sie über alle 50 Sitzungen hinweg und sendete Lösungsanfragen parallel:

// CAPTCHAs über alle 50 Sitzungen lösen
const captchaResult = await browser_solve_captcha();
// { total: 50, detected: 50, solved: 47, failed: 3 }

47 von 50 CAPTCHAs wurden beim ersten Versuch gelöst (15-35 Sekunden). Drei Sitzungen schlugen fehl — der Lösungsdienst überschritt das Zeitlimit. Anstatt den gesamten Batch erneut zu versuchen, wiederholte das Team nur die fehlgeschlagenen Sitzungen:

// Fehlgeschlagene Sitzungen erneut versuchen
const retryResult = await browser_solve_captcha();
// Zielt nur auf Sitzungen ab, die noch ungelöste CAPTCHAs haben
// { total: 3, detected: 3, solved: 3, failed: 0 }

CAPTCHA-Lösung ist der langsamste Schritt in den meisten Registrierungsflüssen. Lösen Sie nach dem Ausfüllen des Formulars (nicht davor), um die Wahrscheinlichkeit des Token-Ablaufs zu minimieren.

Phase 4: Absenden und Verifizierung

Mit ausgefüllten Formularen und gelösten CAPTCHAs war der nächste Schritt, auf die Schaltfläche "Absenden" zu klicken und zu überprüfen, dass die Registrierung erfolgreich war:

// Formular absenden
await browser_parallel_click({ ref: "submit" });

// Auf Erfolgsseite warten
await browser_parallel_wait_for({
  text: "Check your email",
  timeoutMs: 15000
});

// Status überprüfen
const status = await browser_status();

Ergebnisse nach dem Absenden:

46 Sitzungen erreichten die Bestätigungsseite "Check your email"
2 Sitzungen erhielten eine sekundäre Sicherheitsherausforderung (Telefon-Verifizierungsaufforderung)
1 Sitzung erhielt einen "too many requests"-Fehler
1 Sitzung überschritt das Zeitlimit während des Absendens

Phase 5: Fehlerwiederherstellung

Anstatt den gesamten Batch neu zu starten, handhabte das Team jeden Fehlertyp separat:

Telefonverifizierung (2 Sitzungen)

Diese Sitzungen benötigten einen zusätzlichen Schritt. Der KI-Agent erkannte das Telefoneingabefeld, füllte die virtuellen Nummern aus dem Datensatz ein und sendete ab. Beide Sitzungen wurden nach der SMS-Verifizierung abgeschlossen.

Ratenlimitfehler (1 Sitzung)

Der "too many requests"-Fehler war proxy-bezogen — die IP war kürzlich verwendet worden. Das Team wechselte den Proxy der Sitzung und versuchte es erneut. Die Registrierung war beim zweiten Versuch erfolgreich.

Zeitüberschreitung (1 Sitzung)

Ein einfaches Neuladen der Seite und erneutes Absenden behoben dies. Die Formulardaten waren noch ausgefüllt (der Browser behielt sie), daher musste nur die Absendaktion wiederholt werden.

Endergebnis: 50 von 50 Konten erfolgreich registriert. Gesamtzeit von der ersten Navigation bis zur letzten Bestätigung: 23 Minuten.

Was Dies Möglich Machte

Mehrere Faktoren verwandelten dies von einem fragilen Skript in einen zuverlässigen Batch-Betrieb:

Daten pro Profil — Jede Sitzung hatte eindeutige, realistische Daten. Keine Duplikate, keine Muster.
Parallele Ausführung — Alle 50 Sitzungen durchliefen jede Phase zusammen, nicht eine nach der anderen.
Selektive Wiederherstellung — Fehler wurden pro Sitzung behandelt, nicht durch Neustart des Batches. Der KI-Agent identifizierte, was schief gelaufen war, und wendete die richtige Korrektur an.
Statusüberprüfungen zwischen Phasen — `browser_status()`- und `wait_for`-Aufrufe nach jedem Schritt erkannten Abweichungen früh.
CAPTCHA-Wiederholungslogik — Fehlgeschlagene Lösungen wurden einzeln wiederholt, anstatt den gesamten Batch erneut zu lösen.

Zeitaufschlüsselung

Sitzungsstart + Navigation: ~15 Sekunden
Formularausfüllung (50 Sitzungen): ~3 Sekunden
CAPTCHA-Lösung (erster Durchgang): ~35 Sekunden
CAPTCHA-Wiederholung (3 Sitzungen): ~25 Sekunden
Formularabsendung + Verifizierung: ~10 Sekunden
Fehlerwiederherstellung (4 Sitzungen): ~8 Minuten
Gesamt: ~23 Minuten für 50 Konten

Ohne die Fehlerwiederherstellungsphase hätte der glückliche Pfad für 46 Sitzungen etwa 2 Minuten gedauert. Die meiste Gesamtzeit wurde für CAPTCHA-Lösung und Behandlung von Grenzfällen aufgewendet — was in diesem Maßstab zu erwarten ist.

Lektionen zum Weiteren Skalieren

Datenqualität ist der Engpass, nicht die Automatisierungsgeschwindigkeit. Investieren Sie mehr Zeit in realistische Datensätze als in die Optimierung der Klickzeit.
Die Proxy-Qualität beeinflusst direkt die Erfolgsquote. Billige gemeinsame Proxys führen zu Ratenlimits und Blockierungen. Wohn- oder Mobil-Proxys funktionieren deutlich besser.
Führen Sie nicht mehr Sitzungen aus, als Ihre Maschine verarbeiten kann. 50 Chromium-Instanzen benötigen 16-24 GB RAM. Überwachen Sie die Ressourcennutzung und skalieren Sie die Hardware, bevor Sie die Sitzungsanzahl skalieren.
Bauen Sie Wiederherstellung von Anfang an in den Workflow ein. Bei 50+ Profilen sind einige Fehler garantiert. Die Frage ist, ob Sie diese automatisch oder manuell behandeln.
Testen Sie zuerst mit 5 Profilen. Validieren Sie den gesamten Fluss von Ende zu Ende, bevor Sie auf 50 skalieren. Debugging in großem Maßstab ist exponentiell schwieriger.
Verteilen Sie große Batches. Das gleichzeitige Ausführen von 100 Profilen aus demselben IP-Bereich ist ein rotes Tuch. Teilen Sie sie in Gruppen von 20-30 mit Verzögerungen dazwischen auf.