So verwenden Sie die WebScrapingAPI: Leitfaden zur Scraper-API und zum Web MCP

Die Scraper-API ist ein REST-Endpunkt, der eine Ziel-URL entgegennimmt und die Seite als HTML, JSON oder ausgewählte Felder zurückgibt. WebScrapingAPI übernimmt den Betrieb der Proxys, die Rotation, die Zugriffsverwaltung, Wiederholungsversuche und optional das JavaScript-Rendering. Verwenden Sie sie, wenn Sie bereits wissen, welche URLs Sie benötigen, und Seiteninhalte abrufen möchten, ohne eine eigene Scraping-Infrastruktur betreiben zu müssen.

Ihre Anwendung stellt die Ziel-URL und gegebenenfalls den Anfragekontext bereit, wie beispielsweise ein Land oder ein Ausgabeformat. WebScrapingAPI betreibt die Zugriffsebene hinter dieser Anfrage: Proxy-Routing und -Rotation, Strategien zur Zugriffsverwaltung, interne Wiederholungsversuche beim Ziel sowie einen Browser, wenn Sie eine Darstellung anfordern. Als Ergebnis erhalten Sie den Seiteninhalt, ein JSON-Container mit Metadaten, ein JSON-DOM oder nur die von Ihnen ausgewählten Felder. Wenn eine Anfrage nicht abgeschlossen werden kann, erhalten Sie eine explizite, dokumentierte Fehlermeldung anstelle von stillschweigend fehlerhaften Inhalten.

Alles außerhalb dieser Ebene bleibt in Ihrer Verantwortung: Quellen, Zweck, Parsing, Validierung und Speicherung. Die API übernimmt die Proxy- und Browser-Arbeit, nicht jedoch die Arbeit an der Pipeline.

Jeder Tarif, einschließlich der Testversion, umfasst JavaScript-Rendering, Targeting auf Länderebene in allen Regionen sowie Proxy-Rotation mit Zugriffsmanagement. Die Tarife unterscheiden sich hinsichtlich Anforderungsvolumen, Parallelität und Support, nicht hinsichtlich der Funktionen.

Sie sind sich noch nicht sicher, ob eine verwaltete API das Richtige für Sie ist? Informieren Sie sich über die Vor- und Nachteile der Nutzung einer Scraping-API anstelle Ihres eigenen Stacks. Wenn Sie Suchergebnisse, Klicks und Wartezeiten auf einer Seite oder strukturierte Datensätze anstelle von Seiten benötigen, springen Sie direkt zur Auswahl zwischen den fünf Web-Access-APIs.

Erstellen Sie ein Konto, kopieren Sie Ihren API-Schlüssel aus dem Reiter „Web-Scraping-API“ im Dashboard und speichern Sie ihn in einer Umgebungsvariablen. Senden Sie anschließend eine GET-Anfrage an https://api.webscrapingapi.com/v2 mit dem api_key und einer URL-kodierten URL. Lassen Sie Ihre HTTP-Bibliothek die Parameter kodieren und rufen Sie die API niemals aus Browser-Code auf.

1. Registrieren Sie sich. Erstellen Sie ein WebScrapingAPI-Konto und bestätigen Sie es. Die Testversion bietet Ihnen 5.000 Anfragen.
2. Kopieren Sie Ihren Schlüssel. Öffnen Sie im Dashboard die Registerkarte „Web Scraping API“ im linken Bereich und kopieren Sie Ihren API-Schlüssel.
3. Speichern Sie ihn als Geheimnis. Speichern Sie den Schlüssel in einer Umgebungsvariablen auf dem Server, der die Aufrufe durchführt, wie unten gezeigt.
4. Senden Sie die Anfrage. Verwenden Sie eines der folgenden Beispiele.

export WSA_API_KEY=...   # paste your key here, never into code

Schlüssel gehören in serverseitige Geheimnisse, niemals in Browser-Code, mobile Apps, öffentliche Repositorys, Protokolle, Screenshots oder freigegebene Notizbücher. Jeder, der den Schlüssel besitzt, kann die Anfragen Ihres Tarifs verbrauchen.

curl

curl --get "https://api.webscrapingapi.com/v2" \
  --data-urlencode "api_key=$WSA_API_KEY" \
  --data-urlencode "url=https://example.com" \
  --data-urlencode "render_js=1" \
  --data-urlencode "country=us"

--get mit --data-urlencode weist curl an, jeden Parameter in die Abfragezeichenfolge einzufügen und ihn für Sie prozentuell zu kodieren.

Python (Python 3 mit pip install requests)

Dieser kleine Client bildet die Grundlage für den weiteren Verlauf dieses Leitfadens. Er liest den Schlüssel aus WSA_API_KEY, lässt Requests die Abfragezeichenfolge über params= (siehe Requests-Schnellstart) und wiederholt nur die Versuche, bei denen ein Fehler vorliegt, der eine Wiederholung rechtfertigt.

"""Minimal Scraper API client: env-var key, safe retries, optional JSON envelope.

Usage:
  export WSA_API_KEY=...            # never hardcode the key
  python wsa_scrape.py https://example.com
  python wsa_scrape.py https://example.com --render --country us --json
  python wsa_scrape.py https://example.com --dry-run   # print the request, no call
"""
import argparse
import json
import os
import sys
import time

import requests

ENDPOINT = "https://api.webscrapingapi.com/v2"
RETRYABLE = {429, 500, 503}          # back off and retry
FINAL = {400, 401, 403, 406}         # fix the request or the account; do not retry


def build_params(url, render=False, country=None, json_response=False, extract_rules=None):
    params = {"url": url}
    if render:
        params["render_js"] = "1"
    if country:
        params["country"] = country.lower()
    if json_response:
        params["json_response"] = "1"
    if extract_rules:
        # The API expects a JSON-stringified object; requests URL-encodes it.
        params["extract_rules"] = json.dumps(extract_rules, separators=(",", ":"))
    return params


def scrape(url, api_key, max_attempts=4, **opts):
    params = {"api_key": api_key, **build_params(url, **opts)}
    for attempt in range(1, max_attempts + 1):
        resp = requests.get(ENDPOINT, params=params, timeout=130)
        usage = {k: v for k, v in resp.headers.items() if k.lower().startswith("wsa-")}
        if resp.ok:
            return resp, usage
        if resp.status_code in FINAL:
            raise SystemExit(f"{resp.status_code}: {resp.text[:300]}")
        if resp.status_code == 422 and not opts.get("render"):
            # Scrape accepted but not completed (e.g. a challenge page). One rendered retry.
            opts["render"] = True
            params = {"api_key": api_key, **build_params(url, **opts)}
            continue
        if resp.status_code in RETRYABLE or resp.status_code == 422:
            time.sleep(min(2 ** attempt, 30))
            continue
        raise SystemExit(f"Unexpected {resp.status_code}: {resp.text[:300]}")
    raise SystemExit(f"Gave up after {max_attempts} attempts")


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("url")
    ap.add_argument("--render", action="store_true")
    ap.add_argument("--country")
    ap.add_argument("--json", dest="json_response", action="store_true")
    ap.add_argument("--dry-run", action="store_true")
    a = ap.parse_args()
    opts = dict(render=a.render, country=a.country, json_response=a.json_response)

    if a.dry_run:
        prepared = requests.Request("GET", ENDPOINT,
                                    params={"api_key": "REDACTED", **build_params(a.url, **opts)}).prepare()
        print(prepared.url)
        return

    api_key = os.environ.get("WSA_API_KEY")
    if not api_key:
        sys.exit("Set WSA_API_KEY first (dashboard -> Web Scraping API tab).")

    resp, usage = scrape(a.url, api_key, **opts)
    print("status:", resp.status_code)
    print("usage headers:", usage)
    if a.json_response:
        env = resp.json()
        print("initial-status-code:", env.get("initial-status-code"), "cost:", env.get("cost"), "type:", env.get("type"))
        print(env.get("body", "")[:300])
    else:
        print(resp.text[:300])


if __name__ == "__main__":
    main()

Das --dry-run Flag gibt die genaue Anfrage aus, ohne sie zu senden, wobei der Schlüssel unkenntlich gemacht wird. Hier ist ein Beispiel mit einer problematischen Zieladresse, die ein Leerzeichen und ein ?und ein &:

python wsa_scrape.py 'https://example.com/a b?x=1&y=2' --render --country US --json --dry-run

https://api.webscrapingapi.com/v2?api_key=REDACTED&url=https%3A%2F%2Fexample.com%2Fa+b%3Fx%3D1%26y%3D2&render_js=1&country=us&json_response=1

Node.js (Node 18 oder höher, integriert fetch und URLSearchParams)

// Build a Scraper API request URL in Node 18+ without sending it.
// URLSearchParams handles encoding of the target URL and the extract_rules JSON.
const ENDPOINT = "https://api.webscrapingapi.com/v2";

export function buildScrapeUrl(apiKey, target, opts = {}) {
  const params = new URLSearchParams({ api_key: apiKey, url: target });
  if (opts.renderJs) params.set("render_js", "1");
  if (opts.country) params.set("country", opts.country);
  if (opts.extractRules) params.set("extract_rules", JSON.stringify(opts.extractRules));
  return `${ENDPOINT}?${params}`;
}

const target = "https://example.com/search?q=web scraping&page=2";
const url = buildScrapeUrl("REDACTED", target, {
  renderJs: true,
  country: "us",
  extractRules: { title: { selector: "h1", output: "text" } },
});
console.log(url);

// Round-trip check: the API sees exactly the original target and rules.
const parsed = new URL(url).searchParams;
console.log("url param decodes to original:", parsed.get("url") === target);
console.log("extract_rules parses:", JSON.parse(parsed.get("extract_rules")).title.selector);

// Live call (server-side only): uncomment with WSA_API_KEY set.
// const res = await fetch(buildScrapeUrl(process.env.WSA_API_KEY, "https://example.com"));
// console.log(res.status, res.headers.get("wsa-call-credit-usage"), (await res.text()).slice(0, 200));

Ausgabe:

https://api.webscrapingapi.com/v2?api_key=REDACTED&url=https%3A%2F%2Fexample.com%2Fsearch%3Fq%3Dweb+scraping%26page%3D2&render_js=1&country=us&extract_rules=%7B%22title%22%3A%7B%22selector%22%3A%22h1%22%2C%22output%22%3A%22text%22%7D%7D
url param decodes to original: true
extract_rules parses: h1

Warum die Kodierung wichtig ist. Die Ziel-URL wird innerhalb der Abfragezeichenfolge einer anderen URL übertragen. Wenn Sie https://example.com/search?q=web scraping&page=2 im Rohformat einfügen, wird der & wird der url Parameter vorzeitig ab, und page=2 erreicht die API als eigenständiger Parameter. Das Scraping „funktioniert“ zwar immer noch, aber auf der falschen Seite. Die in RFC 3986 definierte Prozent-Kodierung wandelt ? in %3F und & in %26 , sodass das gesamte Ziel erhalten bleibt. Überlassen Sie dies einer Bibliothek: URLSearchParams in Node, params= in Requests oder --data-urlencode in curl. Die oben beschriebene Round-Trip-Prüfung belegt, dass die API genau die Zeichenkette erhält, mit der Sie begonnen haben.

Bevorzugen Sie eine Client-Bibliothek? WebScrapingAPI bietet veröffentlichte SDKs für Node.js, Python, Java, PHP und Rust sowie eine Scrapy-Integration. Für das Parsen und Crawlen über den API-Aufruf hinaus sehen Sie sich diese Python-Scraping-Muster jenseits des API-Aufrufs an.

Dokumentation: Eine Anfrage senden.

Nur „api_key“ und „url“ sind erforderlich. Fügen Sie „render_js“ für clientseitig gerenderte Seiten, „country“, „city“, „state“ oder „asn“ für den Standort, „extract_rules“ oder „json_response“ für strukturierte Ausgabe, „async“ für langsame Seiten sowie „method“ mit „body“ für POST, PUT oder PATCH hinzu. „timeout“ ist standardmäßig auf 120.000 Millisekunden eingestellt und darf diesen Wert nicht überschreiten.

Tabelle 1: Scraper-API-Parameter

Boolesche Parameter akzeptieren 1 oder true , um eine Funktion ein- und 0 oder false zum Ausschalten, also render_js=1 und render_js=true bedeuten dasselbe. snapshot_id ersetzt url anstatt es anzuhängen: Man sendet es nur, wenn man das Ergebnis eines asynchronen Jobs abruft.

POST, PUT und PATCH werden an denselben /v2 Endpunkt mit einer body Nutzdaten, und in der Dokumentation werden sie als Beta-Funktionen gekennzeichnet. Testen Sie sie an einem harmlosen Echo-Ziel wie https://httpbin.org/post , bevor Sie sie auf ein echtes Formular richten. Wenn Sie lieber schnell einen Fehler erhalten möchten, als bis zu zwei Minuten auf ein langsames Ziel zu warten, stellen Sie timeout eine niedrigere Anzahl von Millisekunden ein.

Beginnen Sie bei jedem neuen Ziel mit den beiden erforderlichen Parametern, prüfen Sie die Rückmeldung und fügen Sie die Optionen nacheinander hinzu. Jede Option sollte ihren Platz verdienen, indem sie ein Problem behebt, das Sie in der reinen Antwort festgestellt haben.

Dokumentation: API-Parameter.

Aktiviere „render_js=1“ nur dann, wenn die benötigten Daten im reinen HTML fehlen, weil die Seite diese mit JavaScript generiert. Rufe die Seite zunächst ohne Rendering ab und überprüfe sie auf deine Zielfelder. Das Rendering kostet bei der Scraper-API keine zusätzlichen Credits, ist jedoch langsamer als ein reiner HTTP-Abruf; setze es daher nur pro Ziel ein.

Der Test erfordert eine einzige Anfrage. Wähle einen Wert, den du in einem normalen Browser sehen kannst, z. B. einen Preis, rufe die Seite ohne Rendering ab und suche im Antworttext danach. Wenn er vorhanden ist, überspringe das Rendering. Fehlt er, wird er von der Seite nach dem Laden per JavaScript generiert; versuche es daher erneut mit render_js=1.

Entscheide pro Ziel, nicht pro Projekt, und speichere die Einstellung neben jedem Ziel in deiner Konfiguration. Die Übersichtsseiten einer Website liefern möglicherweise vollständigen HTML-Code, während ihre Produktseiten Preise aus einem Skript laden.

Das Rendern steht auch in Wechselwirkung mit Fehlern. In der Dokumentation wird eine Challenge-Seite aufgeführt, die zurückgegeben wird, nachdem render_js deaktiviert wurde, als eine Ursache für eine 422-Antwort auf. Deshalb führt die Wiederholungsrichtlinie in diesem Leitfaden nach einem 422 genau einen Renderversuch durch, bevor sie aufgibt. Du kannst das Rendern auch mit json_dom=1 , wenn Sie die gerenderte Seite als JSON-Baum erhalten möchten.

Das Rendering hat jedoch seine Grenzen. Wenn die Daten erst erscheinen, nachdem du auf ein bestimmtes Element gewartet, auf eine Schaltfläche geklickt, gescrollt, etwas in ein Feld eingegeben oder einen Screenshot gemacht hast, geht dies über den Rahmen einer einzelnen Scraper-API-Anfrage hinaus. Das ist die Aufgabe der Browser-API.

Füge einen zweistelligen Ländercode wie „us“, „de“ oder „gb“ hinzu. Grenzen Sie die Suche weiter ein mit der Stadt (Kleinbuchstaben, keine Leerzeichen), dem Bundesstaat für Städte in den USA oder Australien oder „asn“, um ein Netzwerk auszuwählen. Geotargeting kostet keine zusätzlichen Credits. Die Verfügbarkeit von Stadt- und ASN-Zielen kann je nach Tarif und Region variieren; greife daher bei Bedarf auf die Länderebene zurück.

Preise, Lagerbestände, Sprache und Suchergebnisse ändern sich oft je nach Standort des Besuchers. Der country Parameter leitet Ihre Anfrage über einen Proxy in diesem Land weiter und city, stateund asn sie weiter einzugrenzen. city benötigt immer countryund state dient der Eindeutigkeit von Städten in us oder au.

Um die Route zu bestätigen, bevor Sie ihr vertrauen, nutzen Sie einen IP-Echo-Dienst. Diese Anfrage fragt nach einem Ausgang in Berlin und gibt die IP-Adresse zurück, die das Ziel gesehen hat:

curl --get "https://api.webscrapingapi.com/v2" \
  --data-urlencode "api_key=$WSA_API_KEY" \
  --data-urlencode "url=https://httpbin.org/ip" \
  --data-urlencode "country=de" \
  --data-urlencode "city=berlin"

Die Ausrichtung auf Länderebene ist für alle Regionen in jedem Tarif enthalten. Eine feinere Ausrichtung ist weniger sicher: Die genaue Verfügbarkeit kann vom aktuellen Tarif, der Region und der Route abhängen. Behandeln Sie Stadt und ASN daher als Empfehlungen, nicht als Garantien. Wenn eine Option nicht verfügbar ist, versuchen Sie es erneut auf Länderebene und bestätigen Sie während der Testphase die Standorte, die Ihre Workload benötigt.

Google ist der einzige Ort, an dem Sie nicht auf country. In der Dokumentation wird darauf hingewiesen, Googles eigenen gl mit denen der Scraper-API country in derselben Anfrage zu kombinieren. Verwenden Sie für Suchergebnisse die SERP-API, die Standort und Sprache als Teil der Suche selbst berücksichtigt.

Übergeben Sie `extract_rules` als JSON-String-Objekt, das Ausgabennamen CSS- oder XPath-Selektoren zuordnet. Jede Regel kann Text, HTML, ein Attribut, eine Tabelle oder verschachtelte Felder zurückgeben – jeweils für jede Übereinstimmung und bereinigt um Leerzeichen. Die API gibt dann JSON mit einer Eigenschaft pro Regel anstelle der gesamten Seite zurück.

Die kürzeste Form ordnet einen Namen einem CSS-Selektor zu und gibt den Text des ersten Treffers zurück:

{"title": "h1"}

Die Form mit dem Regelobjekt fügt Optionen hinzu. Verwende sie, wenn du ein Attribut, HTML, alle Übereinstimmungen oder eine Tabellenauswertung benötigst:

{
  "title": {"selector": "h1", "output": "text"},
  "links": {"selector": "a", "output": "@href", "all": 1}
}

Die Optionen sind:

• selector: ein CSS-Selektor oder ein XPath-Ausdruck. Selektoren, die mit / , werden als XPath behandelt, es sei denn, Sie legen selector_type auf css oder xpath.
• output: text (Standard) festlegen, html, @attr für ein Attribut wie @href, table_json, table_arrayoder ein verschachteltes Regelobjekt.
• all: 1 gibt jede Übereinstimmung zurück, 0 nur die erste.
• clean: 1 Entfernt führende und nachgestellte Leerzeichen sowie Zeilenumbrüche aus dem Text.

Verschachtelte Regeln verarbeiten wiederholte Karten, Zeilen oder Suchergebnisblöcke. Sie wählen das äußere Element mit all: 1aus und definieren anschließend die Felder, die aus jedem Treffer extrahiert werden sollen. Die Antwort verpackt jeden Wert in eine Liste, erwarten Sie also "title": ["..."] anstatt einer bloßen Zeichenkette.

Zeigen Sie eine Vorschau Ihrer Selektoren auf einer gespeicherten Kopie der Seite an, bevor Sie Credits ausgeben. Speichern Sie den HTML-Code der Zielseite einmal und iterieren Sie dann lokal über Ihre Regeln, bis diese das erwartete Ergebnis liefern. Das folgende Skript ist eine lokale Annäherung zur Überprüfung von CSS-Selektoren mit Beautiful Soup – nicht mit der API-eigenen Engine –, unterstützt jedoch die hier gezeigten Regeloptionen. Installieren Sie es mit pip install beautifulsoup4.

Das Fixture (fixture.html):

<html><body>
  <h1>  Example Store  </h1>
  <div class="result"><h2>Blue Mug</h2><a href="/p/blue-mug">view</a><span class="price">$12.00</span></div>
  <div class="result"><h2>Red Mug</h2><a href="/p/red-mug">view</a><span class="price">$14.50</span></div>
  <table id="specs"><tr><th>Size</th><th>Material</th></tr><tr><td>350 ml</td><td>Ceramic</td></tr></table>
</body></html>

Das Vorschau-Skript (preview_rules.py):

"""Preview extract_rules selectors locally on saved HTML before spending credits.

This is a local approximation for checking CSS selectors, not the API's own engine.
It supports the rule options used here: selector, output (text, html, @attr, nested), all, clean.
"""
import json
import sys
from bs4 import BeautifulSoup

RULES = {
    "title": {"selector": "h1", "output": "text", "clean": 1},
    "products": {
        "selector": ".result",
        "all": 1,
        "output": {
            "name": {"selector": "h2", "output": "text"},
            "url": {"selector": "a", "output": "@href"},
            "price": {"selector": ".price", "output": "text"},
        },
    },
}


def apply_rule(node, rule):
    if isinstance(rule, str):
        rule = {"selector": rule}
    matches = node.select(rule["selector"])
    if not rule.get("all"):
        matches = matches[:1]
    out = rule.get("output", "text")
    values = []
    for m in matches:
        if isinstance(out, dict):
            values.append({k: first(apply_rule(m, r)) for k, r in out.items()})
        elif out == "html":
            values.append(str(m))
        elif out.startswith("@"):
            values.append(m.get(out[1:]))
        else:
            text = m.get_text()
            values.append(text.strip() if rule.get("clean") else text)
    return values


def first(v):
    return v[0] if v else None


html = open(sys.argv[1] if len(sys.argv) > 1 else "fixture.html").read()
soup = BeautifulSoup(html, "html.parser")
print(json.dumps({k: apply_rule(soup, r) for k, r in RULES.items()}, indent=2))
print("extract_rules param:", json.dumps(RULES, separators=(",", ":"))[:80], "...")

Ausgabe:

{
  "title": [
    "Example Store"
  ],
  "products": [
    {
      "name": "Blue Mug",
      "url": "/p/blue-mug",
      "price": "$12.00"
    },
    {
      "name": "Red Mug",
      "url": "/p/red-mug",
      "price": "$14.50"
    }
  ]
}
extract_rules param: {"title":{"selector":"h1","output":"text","clean":1},"products":{"selector":".re ...

Sobald die Vorschau korrekt aussieht, übergeben Sie dasselbe RULES Dictionary an build_params(..., extract_rules=RULES) im Python-Client übergeben, der es für Sie serialisiert und kodiert. Beim manuellen Erstellen der Abfragezeichenfolge passieren die meisten Fehler. Wenn der Wert kein in eine Zeichenkette umgewandeltes Objekt ist, lehnt die API die Anfrage mit einem Validierungsfehler ab:

{"status": "Failure", "status_code": 400, "error": "Key `extract_rules` must be a stringified object."}

Die Regeln, das Schema und die Aktualisierung der Selektoren bei Änderungen an einer Website liegen weiterhin in Ihrer Verantwortung.

Dokumentation: Extraktionsregeln.

Füge `json_response=1` hinzu, um das Ergebnis in JSON zu verpacken – einschließlich der Header des Ziels, des ursprünglichen Statuscodes, des Hauptteils, des Typs (html, json oder b64), der Kreditkosten sowie der extrahierten Mikrodaten und JSON-LD-Metadaten. Verwende diese Option, wenn deine Pipeline Metadaten speichert oder den tatsächlichen Statuscode des Ziels benötigt. Andernfalls analysieren Sie den Rohtext des Hauptteils.

Standardmäßig gibt die Scraper-API den Seiteninhalt direkt zurück, was den Anforderungen der meisten HTML-Parser entspricht. Die JSON-Hülle ist für Pipelines gedacht, die mehr über jeden Abruf wissen müssen: mit welchem Status das Ziel tatsächlich geantwortet hat, wie hoch die Kosten waren und welche strukturierten Daten die Seite enthielt.

Der Envelope verfügt über sechs Felder: headers (die Antwort-Header des Ziels), cost (Credits für die Anfrage), initial-status-code (der erste Statuscode des Ziels), body (den Seiteninhalt), type (html, json, oder b64) sowie metadata (extrahierte Mikrodaten und JSON-LD).

Dieser Parser überprüft den Status des Ziels, bevor er Daten speichert, dekodiert binäre Inhalte und liest die Kosten aus. Die Eingabe ist eine Beispieldatei, die den dokumentierten Feldsatz widerspiegelt, und keine Live-Ausgabe:

"""Parse a json_response=1 envelope. sample_envelope.json mirrors the documented field set;
it is a SAMPLE, not live output."""
import base64
import json
import sys
from bs4 import BeautifulSoup

env = json.load(open(sys.argv[1] if len(sys.argv) > 1 else "sample_envelope.json"))

status = env["initial-status-code"]
if status >= 400:
    raise SystemExit(f"Target answered {status}; inspect before storing")

body = env["body"]
if env.get("type") == "b64":               # binary targets arrive base64-encoded
    body = base64.b64decode(body)

print("cost (credits):", env["cost"])
print("content-type:", env["headers"].get("content-type"))
print("json-ld blocks:", len(env["metadata"]["json-ld"]))
if env.get("type") == "html":
    print("title:", BeautifulSoup(body, "html.parser").title.get_text())

Ausgabe für die Beispieldatei:

cost (credits): 1
content-type: text/html; charset=UTF-8
json-ld blocks: 0
title: Example Domain

Es gibt außerdem json_dom=1, das die Seite als DOM-ähnlichen JSON-Baum zurückgibt. Wenn Sie bestimmte Felder benötigen, sind Extraktionsregeln in der Regel einfacher als das Durchlaufen eines gesamten Baums.

Sie benötigen den Envelope nicht, um die Kosten zu verfolgen. Jede Antwort enthält benutzerdefinierte Header mit einem WSA- Präfix:

• WSA-Scraped-Resolved-Url: die endgültige URL nach Weiterleitungen
• WSA-Scraped-Headers: die Antwort-Header des Ziels
• WSA-Client-Cookies: von JavaScript nach dem Laden der Seite gesetzte Cookies
• WSA-Call-Credit-Usage: die für diese Anfrage verbrauchten Credits
• WSA-Current-Credit-Usage: Gesamtzahl der nach dieser Anfrage verbrauchten Credits

Protokolliere bei jedem Aufruf die beiden Credit-Header. Der oben genannte Python-Client sammelt bereits alle WSA- Header in seinem usage Wörterbuch. Nach einer Woche Laufzeit zeigen dir diese Protokolle, welche Ziele am teuersten sind und welchen Tarif du benötigst. Informationen zur Speicherung und Validierung desselben Jobs findest du unter „Erstellen deiner ersten zuverlässigen Datenpipeline“.

Senden Sie die Anfrage mit `async=true`. Die API stellt den Scrape in die Warteschlange und gibt sofort eine `response_id` zurück. Rufen Sie später denselben `/v2`-Endpunkt auf, wobei `api_key` und `snapshot_id` auf diese ID gesetzt sind, um die fertige Seite abzurufen. Führen Sie Abfragen mit zunehmenden Verzögerungen durch, anstatt Verbindungen offen zu halten, und speichern Sie die ID zusammen mit dem Job.

Eine synchrone Anfrage hält eine Verbindung offen, bis die Seite zurückkommt – bis zu 120 Sekunden lang. Das ist für eine Handvoll URLs in Ordnung, aber unpraktisch bei langsamen Zielen, großen Stapeln oder Workern, die nicht zwei Minuten pro Anfrage warten können. Async teilt den Aufruf in „Submit“ und „Collect“ auf:

"""Queue a long scrape with async=true, then poll by snapshot_id.

Needs WSA_API_KEY. Without it, prints the two request shapes (key redacted)."""
import os
import time
import requests

ENDPOINT = "https://api.webscrapingapi.com/v2"
key = os.environ.get("WSA_API_KEY")
target = "https://example.com/"

if not key:
    for p in ({"api_key": "REDACTED", "url": target, "async": "true"},
              {"api_key": "REDACTED", "snapshot_id": "<response_id>"}):
        print(requests.Request("GET", ENDPOINT, params=p).prepare().url)
    raise SystemExit("dry run: set WSA_API_KEY to run live")

job = requests.get(ENDPOINT, params={"api_key": key, "url": target, "async": "true"}, timeout=30).json()
snapshot_id = job["response_id"]
for delay in (2, 4, 8, 16, 30, 30):
    time.sleep(delay)
    r = requests.get(ENDPOINT, params={"api_key": key, "snapshot_id": snapshot_id}, timeout=60)
    if r.ok and r.text.lstrip().startswith("<"):
        print(r.text[:200])
        break
    print("not ready:", r.status_code, r.text[:120])

Ohne Schlüssel gibt das Skript die beiden Anfrageformate aus, die es senden würde:

https://api.webscrapingapi.com/v2?api_key=REDACTED&url=https%3A%2F%2Fexample.com%2F&async=true
https://api.webscrapingapi.com/v2?api_key=REDACTED&snapshot_id=%3Cresponse_id%3E
dry run: set WSA_API_KEY to run live

Die Abfrageschleife ist bewusst konservativ ausgelegt. Sie hält zwischen den Versuchen eine Pause ein und behandelt alles, was keine fertige HTML-Seite ist, als „noch nicht bereit“. Speichere in der Produktion den response_id mit dem Job-Datensatz, sobald Sie ihn erhalten, damit bei einem Neustart des Workers keine fertigen Ergebnisse verloren gehen. Sammeln Sie Snapshots umgehend, anstatt davon auszugehen, dass sie unbegrenzt warten.

Behandeln Sie die Statuscodes 400, 401, 403 und 406 als Hinweise auf Korrekturen an Ihrer Anfrage oder Ihrem Konto, nicht als Gründe für Wiederholungsversuche. Bei den Statuscodes 429, 500 und 503 sollten Sie eine Wartezeit einlegen und es erneut versuchen. Ein 422 bedeutet, dass die API die Anfrage akzeptiert hat, das Scraping jedoch nicht abschließen konnte – beispielsweise bei einer Challenge-Seite, die als HTTP 200 zurückgegeben wurde. Versuchen Sie es daher einmal mit Rendering, bevor Sie aufgeben.

Tabelle 2: Statuscodes und entsprechende Maßnahmen

Die scrape() Funktion im Python-Client implementiert diese Tabelle. Endgültige Fehler (400, 401, 403, 406) werden sofort mit dem Antworttext beendet, da das erneute Senden derselben Anfrage auf dieselbe Weise fehlschlagen würde. Wiederholbare Fehler (429, 500, 503) werden mit exponentiellem Backoff, begrenzt auf 30 Sekunden, bis zu viermal wiederholt. Ein 422-Fehler bei einer nicht gerenderten Anfrage löst einen Wiederholungsversuch mit Rendering aus. Ein anhaltender 422-Fehler wird dann wie jeder andere wiederholbare Fehler mit Backoff behandelt, bis die Versuche aufgebraucht sind.

Ein 401-Fehler verdient eine genauere Betrachtung, da er zwei verschiedene Probleme abdeckt. Ein fehlender Schlüssel führt zu folgender Meldung:

{"error":"Access denied. No key `api_key` provided."}

Derselbe Code bedeutet auch, dass das Guthabenkontingent Ihres Kontos aufgebraucht ist; überprüfen Sie daher die Planauslastung, bevor Sie Schlüssel rotieren.

Bei einem 429-Fehler liegt die Ursache meist in der Parallelität, nicht in der Geschwindigkeit. Die Tarife erlauben 5 bis 500 gleichzeitige Anfragen; passen Sie daher die Größe Ihres Worker-Pools an Ihren Tarif an, anstatt ihn wachsen zu lassen, bis die API eine Rückmeldung gibt. Die 429-Referenz von MDN behandelt den Status selbst. Wenn ein Ziel nach Wiederholungsversuchen weiterhin fehlschlägt, gehen Sie diese Lösungen für Blockierungen durch, bevor Sie die Tools wechseln.

Dokumentation: Antworten und Fehler.

Die Tarife richten sich nach der Anzahl der monatlichen Anfragen: „Starter“ kostet 19 $ für 7.000, „Basic“ 49 $ für 20.000, „Standard“ 99 $ für 45.000, „Advanced“ 149 $ für 100.000, „Premium“ 249 $ für 180.000 und „Pro“ 599 $ für 450.000. Die Testversion umfasst 5.000 Anfragen. JavaScript-Rendering und Geotargeting kosten in keinem Tarif zusätzliche Credits.

Tabelle 3: Tarife der Scraper-API (Preise Stand Oktober 2026)

Der effektive Preis pro 1.000 Anfragen sinkt vom Starter- zum Pro-Tarif um etwa die Hälfte, daher ist das Volumen bei der Auswahl eines Tarifs wichtiger als die Funktionen. Auch die gleichzeitige Auslastung spielt eine Rolle: Wenn Ihre Pipeline 100 gleichzeitig laufende Anfragen benötigt, legt dies eine Untergrenze fest, unabhängig vom monatlichen Volumen.

Um zu sehen, wie viel Sie tatsächlich ausgeben, nutzen Sie die von der API gemeldeten Kosten pro Aufruf: das cost Feld im JSON-Envelope oder den WSA-Call-Credit-Usage Header. Testen Sie Ihren tatsächlichen Zielmix in der Testversion, protokollieren Sie diese Werte und hochrechnen Sie sie auf einen Monat. So erfahren Sie besser als durch jede Schätzung, welcher Tarif am besten passt.

Verwenden Sie die Scraper-API, wenn Sie URLs haben und den Seiteninhalt benötigen. Verwenden Sie die Browser-API, wenn die Seite Wartezeiten, Klicks, Eingaben oder Screenshots erfordert. Verwenden Sie die SERP-API für Suchergebnisse, die Crawl-API für eine begrenzte Menge verwandter Seiten und die Data-API für strukturierte Datensätze aus unterstützten Quellen.

WebScrapingAPI bietet fünf Web-Access-APIs an. Diese überschneiden sich weniger, als ihre Namen vermuten lassen, da jede von einer anderen Eingabe ausgeht.

Tabelle 4: Welche Web-Access-API eignet sich für die jeweilige Aufgabe?

Gehen Sie diese Fragen der Reihe nach durch und halten Sie beim ersten „Ja“ an:

1. Gehen Sie von einer Suchanfrage aus? Verwenden Sie die SERP-API. Sie liefert strukturierte Ergebnisse nach Suchmaschine, Standort und Sprache, sodass Sie die Ergebnisseiten nicht selbst auswerten müssen.
2. Gehört Ihre Quelle zu den von der Data-API unterstützten Quellen, und möchten Sie Datensätze statt Seiten? Verwenden Sie die Data-API. Sie deckt 116 unterstützte öffentliche Quellen ab, und WebScrapingAPI pflegt die Parser.
3. Benötigen Sie eine definierte Sammlung verwandter Seiten statt jeweils nur einer URL? Verwenden Sie die Crawl-API für begrenzte mehrseitige Sammlungen.
4. Benötigt die Seite Wartezeiten, Klicks, Texteingaben, Navigationsschritte oder einen Screenshot? Verwenden Sie die Browser-API, die hinter einer REST-Anfrage einen gehosteten Browser ausführt.
5. Andernfalls nutzen Sie die Scraper-API, render_js=1 allerdings nur dann, wenn im reinen HTML Ihre Daten fehlen.

Die APIs lassen sich zudem gut kombinieren. Ein gängiger Arbeitsablauf nutzt die SERP-API, um Ergebnis-URLs zu ermitteln, lässt Ihre Anwendung die relevanten auswählen und ruft diese Seiten dann mit der Scraper-API oder der Browser-API ab. Die Preise für die Browser-API und die Crawl-API erfolgen auf Angebotsbasis. Für die Scraper-API, die SERP-API und die Amazon-Quelle der Data-API gibt es ab Oktober 2026 veröffentlichte Monatspläne.

Für einen vollständigen Vergleich, einschließlich der Funktionen der einzelnen APIs und der Aufgaben, die in Ihrer Anwendung verbleiben, vergleichen Sie alle fünf Web-Access-APIs.

Web MCP ist ein gehosteter Model Context Protocol-Server unter https://mcp.webscrapingapi.com/mcp. Ihr Agent stellt über ein dediziertes MCP-Token eine Verbindung her und ruft „web_read“ und „web_read_more“ über die Scraper-API oder die Browser-API sowie „web_search“ über die SERP-API ab. Es nutzt Ihre bestehenden Tarife und Kontingente, und ein Token verursacht keine zusätzliche Belastung des Kontingents.

Web MCP ist kein separates Produkt, das Sie erwerben müssen. Es handelt sich um eine Verbindungsschicht über den API-Zugang, über den Ihr Konto bereits verfügt – ohne Installation eines Pakets und ohne Betrieb eines Servers.

Was Sie benötigen: Sie benötigen ein WebScrapingAPI-Konto mit Zugriff auf die SERP-API, die Web-Scraping-API oder die Browser-API. Außerdem benötigen Sie einen MCP-Client, der den Streamable-HTTP-Transport mit einem benutzerdefinierten Authorization: Bearer Header, dem in RFC 6750 definierten Token-Schema. Clients, die nur die OAuth-Anmeldung unterstützen, können keine Verbindung herstellen.

Einrichtung: Öffnen Sie als Kontoinhaber MCP im Dashboard, kopieren Sie die Server-URL und wählen Sie „Token erstellen“. Das Token wird nur einmal angezeigt; speichern Sie es daher sofort im geheimen Speicher Ihres Clients oder in einem Passwortmanager. Jedes Konto kann bis zu zehn aktive Token haben; ein verlorenes Token sollte widerrufen und ersetzt werden. Ihr Produkt-API-Schlüssel ist kein MCP-Token und gehört nicht in die Verbindungseinstellungen. Clients, die ein mcpServers Objekt akzeptieren, benötigen eine Konfiguration wie diese:

{
  "mcpServers": {
    "webscrapingapi": {
      "url": "https://mcp.webscrapingapi.com/mcp",
      "headers": { "Authorization": "Bearer ${WSA_MCP_TOKEN}" }
    }
  }
}

Ersetzen Sie den Platzhalter durch Ihren MCP-Token aus „Dashboard → MCP“. Einige Clients lesen ihn aus einer Umgebungsvariablen aus, während andere über ein Token-Feld verfügen; die Interpolationssyntax unterscheidet sich je nach Client. Stellen Sie das Tool-Timeout des Clients auf über 60 Sekunden ein.

Tabelle 5: Web-MCP-Tools

Ihr Client erkennt nur die Tools, die Ihr Konto unterstützt. Ohne Zugriff auf die SERP-API kann der Agent zwar weiterhin die von Ihnen angegebenen URLs lesen, aber keine Suche durchführen.

Weiterleitung und Abrechnung. Beim Auslesen wird die Scraper-API verwendet, sofern Ihr Konto über diese verfügt; andernfalls wird die Browser-API genutzt, und ein erfahrener Aufrufer kann mithilfe des backend Argument eine der beiden auswählen. Lesevorgänge über die Scraper-API verbrauchen Credits und sind standardmäßig statisch. Wenn der Agent render_js: true, gilt dies als neue, nach Verbrauch abgerechnete Anfrage. Lesevorgänge über die Browser-API werden immer gerendert und verbrauchen Bandbreite. Bei einer fehlgeschlagenen Anfrage oder einer ausgeschöpften Quote wird niemals auf ein anderes Produkt umgeschaltet.

Limits. Jedes Tool-Ergebnis ist auf 16 KiB begrenzt, sodass lange Seiten in Blöcken ankommen, die Sie mit web_read_more. Seiten mit mehr als 10 MiB HTML-Code geben einen Fehler zurück, und die Erfassung bleibt bis zu einer Stunde lang erhalten. Das Upstream-Timeout beträgt 55 Sekunden. Jedes Token erlaubt vier gleichzeitige Tool-Aufrufe und vier aktive Sitzungen; eine Sitzung endet nach 15 Minuten Inaktivität, einer Stunde oder 1.000 Anfragen.

Einen umfassenden Überblick darüber, wie Agenten Live-Webdaten nutzen, bieten diese agentischen Webzugriffsmuster.

Dokumentation: Web MCP – Erste Schritte sowie Verwendung und Fehler.

Die Scraper-API ruft pro Anfrage eine Seite ab, führt also keine Klicks, Eingaben, Bildlaufvorgänge oder Anmeldungen für Sie durch. Anfragen verfallen nach 120 Sekunden, die Anzahl gleichzeitiger Anfragen ist je nach Tarif begrenzt, und die Abdeckung von Städten oder ASNs variiert. Sie kann eine Seite nicht so gestalten, dass ihre Erfassung rechtmäßig ist. Wählen Sie eine andere API oder ein anderes Tool, wenn diese Einschränkungen ins Gewicht fallen.

• Keine Interaktion. Eine Anfrage liefert eine Seite. Das Warten auf einen Selektor sowie Klicks, Eingaben, Scrollen und Screenshots gehören zur Browser-API.
• Keine Suche. Für Suchmaschinenergebnisse sollten Sie die SERP-API verwenden, anstatt die Ergebnisseiten zu scrapen.
• Jeweils eine URL. Wenn der Auftrag einen definierten Satz verwandter Seiten umfasst, verwaltet die Crawl-API diesen Umfang für Sie.
• 120-Sekunden-Timeout. Langsame Ziele und große Stapel sollten über asynchrone Anfragen abgewickelt werden.
• Parallelität je nach Tarif. Von 5 parallelen Anfragen in der Testversion bis zu 500 im Pro-Tarif. Passen Sie die Anzahl Ihrer Worker entsprechend an.
• Die Standortabdeckung variiert. Die Abdeckung auf Länderebene ist breit, aber die Verfügbarkeit auf Stadt- und ASN-Ebene hängt vom Tarif, der geografischen Lage und der Route ab.
• Seiten mit CAPTCHA können weiterhin fehlschlagen. Die API übernimmt den Zugriff für Sie, doch manche Ziele enden mit einem 422-Fehler. Da die Lösung von CAPTCHAs nicht garantiert wird, sollten Sie bei besonders schwierigen Zielen mit gelegentlichen Fehlern rechnen.

Es gibt außerdem eine Verantwortung, die keine API beseitigen kann. Sie legen fest, welche Quellen zulässig sind und wofür die Daten bestimmt sind. Nutzen Sie den Dienst nur für öffentliche Seiten, deren Daten Sie erfassen dürfen, prüfen Sie die Nutzungsbedingungen jeder Website, befolgen Sie die Vorschriften zum Schutz personenbezogener Daten und beachten Sie die Richtlinien für Webcrawler.

Um zu erfahren, wie Sie Ihren Scraper über Monate hinweg optimal betreiben, lesen Sie diese Best Practices zum Lebenszyklus mit funktionierendem Code. Wägen Sie Optionen außerhalb der WebScrapingAPI ab? Unser Leitfaden zum Vergleich von Scraping-APIs anderer Anbieter deckt das gesamte Spektrum ab.

Senden Sie eine HTTP-Anfrage an den API-Endpunkt mit Ihrem API-Schlüssel und der gewünschten URL und lesen Sie dann die Seite aus der Antwort aus. Bei WebScrapingAPI ist das ein GET-Aufruf an https://api.webscrapingapi.com/v2 mit dem API-Schlüssel und einer URL-kodierten Adresse. Fügen Sie Rendering-, Standort- oder Extraktionsparameter nur hinzu, wenn das Ziel dies erfordert.

Installieren Sie „Requests“, speichern Sie Ihren Schlüssel in einer Umgebungsvariablen und übergeben Sie „api_key“ und „url“ im Argument „params“, damit „Requests“ diese codiert. Überprüfen Sie den Statuscode, wiederholen Sie Versuche bei 429- und 5xx-Antworten mit Backoff und analysieren Sie den Body mit Ihrem HTML-Parser oder fordern Sie die API mit „extract_rules“ auf, JSON zurückzugeben.

Ja. Die Testversion der Scraper-API umfasst 5.000 Anfragen und ist zu Beginn kostenlos, wobei fünf gleichzeitige Anfragen möglich sind. JavaScript-Rendering und Targeting auf Länderebene sind enthalten, sodass Sie die für Sie wichtigen Ziele testen können, bevor Sie sich für einen kostenpflichtigen Tarif entscheiden. Kostenpflichtige Tarife beginnen bei 19 US-Dollar pro Monat für 7.000 Anfragen.

Nein. Bei der Scraper-API verbrauchen „render_js=1“ und Geotargeting in keinem Tarif zusätzliche Credits. Das Rendering ist jedoch langsamer als ein einfacher Abruf; aktivieren Sie es daher nur für Seiten, bei denen Daten im ursprünglichen HTML-Code fehlen. Überprüfen Sie den Header „WSA-Call-Credit-Usage“, um zu sehen, was bei jedem Aufruf verbraucht wurde.

Es handelt sich um einen Dienst, der Webseiten für Sie abruft und deren Inhalt oder ausgewählte Felder in einem nutzbaren Format zurückgibt. Der Anbieter betreibt Proxys, Wiederholungsversuche und Browser, und Sie senden eine URL sowie Optionen. Die Scraper-API von WebScrapingAPI gibt HTML, einen JSON-Envelope oder Felder zurück, die mit CSS- oder XPath-Extraktionsregeln ausgewählt wurden.

Technisch gesehen können viele öffentliche Seiten abgerufen werden, aber nicht jede Seite sollte dies auch sein. Manche Inhalte sind hinter Anmeldungen verborgen, manche Seiten erfordern eine Interaktion mit dem Browser, und Nutzungsbedingungen oder Datenschutzgesetze können die Datenerfassung einschränken. Verwenden Sie die Scraper-API für öffentliche Seiten, deren Daten Sie erfassen dürfen, und die Browser-API, wenn Seiten eine Interaktion erfordern.

Rufen Sie die Seiten ab und extrahieren Sie die Felder selbst, oder lassen Sie eine Scraping-API das Abrufen übernehmen. Senden Sie bei der Scraper-API die Seiten-URL zusammen mit `extract_rules`, die Feldnamen CSS-Selektoren zuordnen, und Sie erhalten JSON als Antwort. Testen Sie die Selektoren zunächst an einer gespeicherten Kopie der Seite, um unnötige Anfragen zu vermeiden.

Die Scraper-API übernimmt Proxy-Routing, Rotation und Zugriffsstrategien, verspricht jedoch keine CAPTCHA-Lösung. Wenn eine Zielseite eine Challenge-Seite mit HTTP-Status 200 zurückgibt, kann die API das Scraping als 422-Fehler klassifizieren, anstatt Ihnen fehlerhafte Inhalte zu übermitteln. Versuchen Sie es einmal erneut mit Rendering und überprüfen Sie dann die Zielseite.

Sie benötigen ein WebScrapingAPI-Konto mit Zugriff auf die Scraper-API, die Browser-API oder die SERP-API, ein dediziertes MCP-Token aus dem Dashboard sowie einen MCP-Client, der „Streamable HTTP“ mit einem „Bearer“-Header unterstützt. Richten Sie den Client auf https://mcp.webscrapingapi.com/mcp aus. Clients, die nur die OAuth-Anmeldung unterstützen, können keine Verbindung herstellen.

Ja, wenn Seiten über die Scraper-API ausgelesen werden. Jeder „web_read“ ist eine normale, kontingentierte Anfrage, und ein erneuter Versuch mit Rendering ist eine weitere Anfrage. „web_read_more“ setzt dieselbe Erfassung fort, ohne dass neue Kosten anfallen. Suchanfragen verbrauchen Ihr SERP-API-Kontingent, und das Erstellen eines MCP-Tokens erhöht das Kontingent nicht.

Die Scraper-API verwaltet Proxys, Rotation, Wiederholungsversuche und JavaScript-Rendering hinter einer einzigen Anfrage. Rendering und Geotargeting kosten keine zusätzlichen Credits, und fehlgeschlagene Anfragen werden nicht in Rechnung gestellt. Wählen Sie einen Tarif aus, sobald Sie durch die Testphase erkennen, was Sie benötigen.

Einen KI-Agenten einbinden? Fügen Sie die SERP-API hinzu, damit Web MCP sowohl suchen als auch lesen kann. Die Testversion umfasst 100 Google-Suchen.