Neu in ScrapeUnblocker: Mit einer Seite interagieren und sie dann scrapen

ScrapeUnblocker ist unsere Web-Scraping-API: Du gibst ihr eine URL, und sie liefert dir das vollständig gerenderte HTML dieser Seite zurück und überwindet dabei den Anti-Bot-Schutz für dich. Heute fügen wir eine neue Fähigkeit hinzu. Bevor ScrapeUnblocker dir das HTML übergibt, kann es nun mit der Seite interagieren.

Das bedeutet, du erreichst die Daten, die erst nach einer Aktion erscheinen: eine Anfrage eintippen und eine Suche ausführen, auf einen “Mehr laden”-Button klicken, ein Land oder eine Währung aus einem Dropdown wählen oder durch ein mehrstufiges Formular gehen - und du erhältst das HTML zurück, das die Seite erreicht hat, nachdem diese Aktionen abgelaufen sind. Eine ergänzende Funktion listet jedes interaktive Element einer Seite auf, damit du genau weißt, worauf du klicken, wo du tippen oder was du auswählen musst. Dieser Beitrag behandelt beides und wie du sie zusammen nutzt.

So nutzt du es

Beide Funktionen sind einfache Query-Parameter an derselben Seitenabruf-Anfrage, die du bereits stellst (dem getPageSource-Endpoint). Es gibt keine neue URL, keinen neuen Tarif und keinen Browser, den du auf deiner Seite betreiben musst.

• list_elements=true liefert statt HTML eine JSON-Karte der interaktiven Elemente der Seite.
• steps=[...] nimmt ein JSON-Array von Aktionen entgegen, die nach dem Laden der Seite ausgeführt werden, und gibt das erreichte HTML zurück.

Fast immer wirst du sie in dieser Reihenfolge verwenden: list_elements, um die Selektoren zu finden, steps, um auf ihnen zu handeln.

Die Elemente einer Seite erkennen

Bevor du auf einer Seite handeln kannst, musst du wissen, was auf ihr ist. Setze list_elements=true, und statt rohem HTML erhältst du eine kompakte JSON-Liste dessen, worauf du einwirken kannst: Buttons, Eingabefelder, Textbereiche, Selects, Links und Formulare. Jedes kommt mit einem sofort einsetzbaren Selektor sowie seinem Text, Namen, Platzhalter und seiner Rolle, sofern vorhanden.

curl -X POST -G "https://api.scrapeunblocker.com/getPageSource" \
  --data-urlencode "url=https://www.example.com/search" \
  --data-urlencode "list_elements=true" \
  -H "X-ScrapeUnblocker-Key: YOUR_API_KEY"

Die Antwort sieht so aus:

{
  "url": "https://www.example.com/search",
  "count": 12,
  "elements": [
    {
      "tag": "input",
      "selector": "#searchInput",
      "type": "text",
      "name": "q",
      "placeholder": "Search products",
      "text": "Search products"
    },
    {
      "tag": "button",
      "selector": "button.search-submit",
      "text": "Search"
    },
    {
      "tag": "select",
      "selector": "select[name=\"country\"]",
      "name": "country",
      "text": "Country"
    }
  ]
}

Da die Seite gemessen wird, nachdem ein echter Browser sie gerendert und hydriert hat, siehst du die Steuerelemente, die ein Nutzer tatsächlich sieht, nicht nur das, was im rohen Markup steht. Die Selektoren sind auf Stabilität ausgelegt: zuerst eine echte #id, dann ein name, danach eine Klasse und zuletzt ein kurzer positionsbasierter Pfad, sodass du jeden von ihnen direkt in einen Schritt übernehmen kannst.

Die Seite mit steps steuern

Sobald du die Selektoren kennst, hängst du steps an: ein JSON-Array von Aktionen, die nach dem Laden der Seite der Reihe nach ausgeführt werden. Wenn die Schritte abgeschlossen sind, erhältst du das resultierende HTML zurück - genau so, als hättest du die Klicks und Tastenanschläge selbst ausgeführt.

Hier ein Suchablauf: Tippe eine Anfrage in das Feld, drücke Enter und warte, bis die Ergebnisse erscheinen, bevor das HTML erfasst wird.

curl -X POST -G "https://api.scrapeunblocker.com/getPageSource" \
  --data-urlencode "url=https://www.example.com/search" \
  --data-urlencode 'steps=[
    {"action":"type","selector":"#searchInput","value":"bmw"},
    {"action":"press_key","value":"Enter"},
    {"action":"wait_for","selector":".results"}
  ]' \
  -H "X-ScrapeUnblocker-Key: YOUR_API_KEY"

Die Antwort ist das vollständig gerenderte HTML der Ergebnisseite. Dasselbe Muster bewältigt einen “Mehr laden”-Button (klicken, auf neue Zeilen warten), ein Filter-Dropdown (eine Option wählen, auf die Aktualisierung der Liste warten) oder einen zweistufigen Ablauf nach dem Muster Anmelden und Ansehen.

Ein paar wichtige Punkte:

• Das Tippen ist menschenähnlich. Die Aktion type gibt den Text Zeichen für Zeichen in natürlichem Tempo ein, statt ihn auf einen Schlag einzufügen, sodass Formulare, die auf echte Tastenanschläge achten, sich normal verhalten.
• Es läuft einmal. Eine Anfrage mit steps kann ein Formular absenden oder den Zustand verändern, daher wird sie ein einziges Mal ausgeführt und nicht im Hintergrund wiederholt. Fordere genau die Folge an, die du willst.
• Es gibt ein Zeitbudget. Die gesamte Folge teilt sich ein begrenztes Aktionsbudget von etwa 30 Sekunden, was für eine Suche oder ein paar Klicks reichlich ist. Nutze wait_for auf dem Element, das du wirklich brauchst, statt eines langen festen wait.

Die Aktionen, die du ausführen kannst

Jeder Schritt ist ein Objekt mit einer action und, je nach Aktion, einem selector und einem value. Die verfügbaren Aktionen sind:

• wait_for - warten, bis ein Element, das zu selector passt, sichtbar ist.
• wait_for_text - warten, bis ein bestimmter Text irgendwo auf der Seite erscheint (value ist der Text).
• wait - eine feste Pause, mit value in Millisekunden.
• click - das Element bei selector anklicken.
• type - value in das Feld bei selector eingeben, Zeichen für Zeichen.
• select - eine Option in einem <select> anhand ihres Werts wählen.
• press_key - eine Taste wie Enter, Tab oder Escape drücken.
• scroll - die Seite scrollen, mit value auf "bottom" oder eine Pixelzahl gesetzt, womit du Inhalte auslöst, die beim Scrollen nachladen.

Selektoren sind standardmäßig CSS. Falls gewünscht, kann ein Schritt "selector_type": "xPath" tragen, um ein Element per XPath anzusprechen.

Wenn ein Schritt fehlschlägt, bekommst du die Seite trotzdem

Wenn ein Schritt nicht abgeschlossen werden kann - ein Selektor passt nie, oder ein Element erscheint nicht rechtzeitig -, gibt die API nicht einfach einen Fehler zurück und verwirft die Arbeit. Sie antwortet mit HTTP 422 und einem JSON-Körper, der genau benennt, welcher Schritt fehlgeschlagen ist und warum, und der das HTML der Seite in dem Zustand enthält, den sie erreicht hat.

{
  "error": "step_failed",
  "step_index": 2,
  "action": "wait_for",
  "reason": "Timeout 8000ms exceeded.",
  "selector": ".results",
  "html": "<!doctype html>..."
}

Dieser step_index sagt dir, dass der dritte Schritt (von null an gezählt) der ist, den du korrigieren musst, und das html zeigt dir, was die Seite tatsächlich getan hat - vielleicht hat der Ergebnis-Container eine andere Klasse als erwartet. Ein fehlerhaftes steps-Payload, etwa eine unbekannte Aktion oder ein fehlender Selektor, wird noch früher erkannt und liefert ein 422, bevor überhaupt ein Browser startet, sodass du nie eine Anfrage für einen Tippfehler verbrauchst.

Wann ist das nützlich

Immer dann, wenn die gewünschten Daten nicht im ersten Rendering stecken, sondern ein oder zwei Interaktionen entfernt sind:

• Suchergebnisse hinter einem Formular. Tippe eine Anfrage, sende sie ab und scrape die Ergebnisseite, statt eine Such-URL zu erraten.
• Paginierte oder Infinite-Scroll-Listen. Klicke auf “Mehr laden” oder scrolle bis ans Ende, warte auf die neuen Zeilen und erfasse eine vollständigere Seite.
• Land-, Währungs- oder Sprachauswahl. Wähle die Option, die du brauchst, damit die Preise und Inhalte, die du scrapest, zum gewünschten Markt passen.
• Mehrstufige Abläufe. Fülle ein Feld aus, gehe zum nächsten, sende ab - und lies die Seite, auf der du landest.
• KI-Agenten, die eine Seite erst verstehen müssen. Ein Agent kann die Elemente auflisten, entscheiden, was zu tun ist, und dann handeln - ohne fest codierte Selektoren.

Erst erkennen, dann handeln: der vollständige Kreislauf

Die beiden Funktionen sind als Paar konzipiert, und genau hier glänzen sie für KI-Agenten und Automatisierung. Ein Agent, der auf einer unbekannten Seite landet, kann Selektoren nicht zuverlässig erraten. Also tut er, was ein Mensch tut: Er schaut zuerst.

1. Rufe list_elements=true auf, um die Steuerelemente der Seite und ihre Selektoren zu erhalten.
2. Entscheide anhand dieser Liste, was zu tun ist - welches Feld auszufüllen, welchen Button zu klicken.
3. Baue ein steps-Array gegen genau diese Selektoren.
4. Rufe den Endpoint mit den Schritten auf und lies das resultierende HTML.

Da Schritt eins echte, stabile Selektoren zurückgibt statt eines Screenshots, den das Modell erst deuten muss, funktioniert der Plan, den der Agent in Schritt drei baut, meist beim ersten Versuch. Und da jeder Aufruf bereits hinter derselben Anti-Bot-Behandlung wie der Rest von ScrapeUnblocker läuft, muss der Agent nie über Blockaden, IP-Rotation oder Rendering nachdenken - er erkennt die Seite und handelt einfach auf ihr.

Beide Funktionen sind jetzt verfügbar. Die vollständige Parameter-Referenz und weitere Beispiele findest du in der Integrationsdokumentation unter docs.scrapeunblocker.com, oder sieh dir die Tarife unter scrapeunblocker.com/pricing an.