Verarbeiten von client-gerenderten Seiten
Use browser-backed retrieval when required content appears only after page JavaScript has executed.
Review request controlsBrowser-API
Browser-API für JavaScript-lastige Seiten
Erhalten Sie gerendertes HTML, ausgewählte Felder oder Screenshots dynamischer Seiten. Senden Sie Wartebedingungen und Seitenaktionen per REST-API; wir betreiben den Browser.
- Statusbewusste WarteschlangenLebenszyklus, Verzögerung oder Selektor
- Geführte AktionenKlicken, Scrollen, Tippen, Auswählen, Absenden
- AnforderungskontextGerät, Viewport, Land
- Wählbarer AusgangHTML, JSON, Felder, Screenshot
Eine klarere Browsergrenze
Gerenderte Seiten erfassen, ohne Browser zu betreiben
Erfassen eines absichtlichen Seitenstatus
Wait for a lifecycle event, delay, selector, or documented instruction step instead of parsing whatever happens to arrive first.
See the request workflowWählen Sie die nützliche Antwort
Return rendered HTML, a JSON response, a JSON DOM, selected fields, or a screenshot for the downstream task.
Compare output optionsIhre Anwendung definiertURL · context · readiness · actions · output
WebScrapingAPI operatesHosted browser execution and response delivery
Ihre Pipeline empfängtOne documented response or explicit error
Anatomie anfordern
Ihre Anfrage konfigurieren
Beginnen Sie mit der URL target und fügen Sie nur die dokumentierten Kontrollen hinzu, die erforderlich sind, um die Seite zu reproduzieren, die Ihre Anwendungsbedürfnisse enthält. Browser-API Parameteranleitung.
Anforderungskontext
Definieren Sie, wie der gehostete Browser die Seite erreicht und einrahmt.
api_key- Serverseitige Authentifizierung
url- URL-codierte öffentliche target
method- Target Anforderungsmethode
body- Optionaler Körper target
country- Unterstützter Länderkontext
timeout- Zeitlimit für Anfragen
device- Desktop, Mobilgerät oder Tablet
window_width- Viewport-Breite
window_height- Viewport Höhe
block_resources- Optionale Ressourcensperrung
Bereitschaft und Aktionen
Teilen Sie der Anfrage mit, wann die Seite fertig ist und was als nächstes zu tun ist.
wait_until- Lebenszykluszustand
wait_for- Explizit-Delay
wait_for_css- Erforderlicher Selektor
js_instructions- Geordnete Interaktionsfolge
auto_solve- Dokumentierte Zutrittskontrolle
clickscrollTotyped_valueselectsubmitclick_and_navigateErfassung und Reaktion
Wählen Sie aus, was die browsergestützte Anforderung zurückgeben soll.
screenshot- Bildaufnahme anfordern
screenshot_options- Erfassungsbereich und -abmessungen
extract_rules- Vom Kunden bereitgestellte CSS- oder XPath-Regeln
json_response- JSON-Antwortumschlag
json_dom- JSON DOM-Darstellung
Verwenden Sie das kleinste stabile Rezept.
Sie bevorzugen einen beobachtbaren Selector oder einen Lebenszykluszustand gegenüber einer willkürlichen Verzögerung, halten die Aktionssequenzen kurz und validieren den zurückgegebenen Inhalt nach Ihren eigenen Geschäftsanforderungen.
Workflow für Anfragen
Von der Anfrage zum Ergebnis
- 01request
Definieren Sie die target
Provide the URL, method, country, device, viewport, and timeout required for the test case.
- 02state
Bereitschaft zum Erreichen
Choose
domcontentloaded,load,networkidle0,networkidle2, a delay, or a selector. - 03interaction
Aktionen ausführen
Apply an ordered
js_instructionssequence when the page needs clicks, scrolling, values, selections, or navigation. - 04output
Rückgabe und Validierung
Receive the requested format or explicit error, then validate content before it enters the downstream system.
- Prefer
- Beobachtbare Bereitschaft
Ein Selektor oder ein Lebenszyklus-Zustand der Seite, der mit dem benötigten Inhalt verbunden ist.
- Keep
- Anleitung minimal
Nur die Aktionen, die erforderlich sind, um einen stabilen, wiederholbaren Zustand zu erreichen.
- Expect
- Explizite Ergebnisse
Die Browser-Exécution kann immer noch fehlgeschlagen, ausfallen oder Inhalte zurückgeben, die eine Geschäftsvalidierung benötigen.
Output-Vertrag
Ihr Ausgabeformat wählen
Erfassen Sie die dargestellte Seite einmal und wählen Sie dann eine dokumentierte Ausgabe aus, die einem bestehenden Parser, einem Validierungsschritt, einer Beweisfassung oder einem Medienworkflow entspricht.
Plain HTML
Geben Sie den dargestellten Seitenkörper für einen Parser- oder Archivprozess zurück, den Ihr Team betreibt.
text/htmlJSON-Hüllkurve
Verpackung des Körpers mit dokumentierter Anfrage und target-Antwort-Kontext zur Inspektion.
json_responseJSON DOM
Erhalt das Seitendokument als JSON DOM-Repräsentation für die Abströmung.
json_domExtrahierte Felder
Führen Sie kundendefinierte CSS- oder XPath-Regeln aus und geben Sie den ausgewählten Inhalt zurück.
extract_rulesScreenshot
Erfassen Sie die gesamte Seite oder ein gewähltes Element und erhalten Sie das Bild als Basis64.
screenshot- Benötigen Sie die Seite?
- Plain HTML or JSON DOM
- Benötigen Sie Antwortkontext?
- JSON envelope
- Benötigen Sie benannte Felder?
- Extraction rules
- Brauchen Sie visuelle Beweise?
- Screenshot
Integration für Entwickler
Von Ihrem Server verbinden
Rufen Sie den REST-Endpunkt von Ihrem Server aus, halten Sie den API-Schlüssel aus dem Client-Code, URL-Code-Anforderungsparameter, setzen Sie eine endliche Zeitfrist und bearbeiten Sie absichtlich nicht erfolgreiche Antworten.
Anfragevorlage
Beginne mit einem beobachtbaren Zustand.
Diese Beispiele warten auf. main Ersetzen Sie den target-Selektor und die Aktionen durch eine Sequenz, die mit Ihrer eigenen berechtigten Quelle validiert ist.
- Endpunkt
https://api.webscrapingapi.com/v1- Secret
WSA_API_KEYin Serverumgebung- Bereitschaft
wait_for_css=main- Aktionen
- JSON-Encoding
js_instructions - Antwort
- Status vor dem Parsen prüfen
: "${WSA_API_KEY:?Set WSA_API_KEY}"
ACTIONS='[{"action":"scrollTo","selector":"main","timeout":1000,"block":"start"}]'
curl --get --fail-with-body --max-time 120 \
"https://api.webscrapingapi.com/v1" \
--data-urlencode "api_key=$WSA_API_KEY" \
--data-urlencode "url=https://example.com/app" \
--data-urlencode "wait_for_css=main" \
--data-urlencode "js_instructions=$ACTIONS" \
--data-urlencode "json_response=1"import json
import os
import requests
api_key = os.getenv("WSA_API_KEY")
if not api_key:
raise RuntimeError("Set WSA_API_KEY")
response = requests.get(
"https://api.webscrapingapi.com/v1",
params={
"api_key": api_key,
"url": "https://example.com/app",
"wait_for_css": "main",
"js_instructions": json.dumps([{
"action": "scrollTo", "selector": "main",
"timeout": 1000, "block": "start"
}]),
"json_response": 1,
},
timeout=120,
)
response.raise_for_status()
print(response.json())const apiKey = process.env.WSA_API_KEY;
if (!apiKey) throw new Error("Set WSA_API_KEY");
const params = new URLSearchParams({
api_key: apiKey,
url: "https://example.com/app",
wait_for_css: "main",
js_instructions: JSON.stringify([{
action: "scrollTo", selector: "main",
timeout: 1000, block: "start"
}]),
json_response: "1",
});
const response = await fetch(
"https://api.webscrapingapi.com/v1?" + params,
{ signal: AbortSignal.timeout(120_000) }
);
if (!response.ok) throw new Error("API status " + response.status);
console.log(await response.json());<?php
$apiKey = getenv("WSA_API_KEY");
if (!$apiKey) throw new RuntimeException("Set WSA_API_KEY");
$actions = json_encode([[
"action" => "scrollTo", "selector" => "main",
"timeout" => 1000, "block" => "start",
]], JSON_THROW_ON_ERROR);
$query = http_build_query([
"api_key" => $apiKey,
"url" => "https://example.com/app",
"wait_for_css" => "main",
"js_instructions" => $actions,
"json_response" => 1,
]);
$client = curl_init("https://api.webscrapingapi.com/v1?" . $query);
curl_setopt_array($client, [
CURLOPT_RETURNTRANSFER => true,
CURLOPT_TIMEOUT => 120,
]);
$body = curl_exec($client);
$status = curl_getinfo($client, CURLINFO_RESPONSE_CODE);
$error = curl_error($client);
curl_close($client);
if ($body === false) throw new RuntimeException($error);
if ($status >= 400) throw new RuntimeException("API status " . $status);
echo $body;package main
import (
"fmt"
"io"
"net/http"
"net/url"
"os"
"time"
)
func main() {
apiKey := os.Getenv("WSA_API_KEY")
if apiKey == "" { panic("Set WSA_API_KEY") }
params := url.Values{}
params.Add("api_key", apiKey)
params.Add("url", "https://example.com/app")
params.Add("wait_for_css", "main")
params.Add("js_instructions", "[{\"action\":\"scrollTo\",\"selector\":\"main\",\"timeout\":1000,\"block\":\"start\"}]")
params.Add("json_response", "1")
client := &http.Client{Timeout: 120 * time.Second}
response, err := client.Get(
"https://api.webscrapingapi.com/v1?" + params.Encode(),
)
if err != nil { panic(err) }
defer response.Body.Close()
if response.StatusCode >= 400 {
panic(fmt.Sprintf("API status %d", response.StatusCode))
}
body, err := io.ReadAll(response.Body)
if err != nil { panic(err) }
fmt.Println(string(body))
}import java.net.URI;
import java.net.URLEncoder;
import java.net.http.*;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
public final class BrowserApiExample {
public static void main(String[] args) throws Exception {
var apiKey = System.getenv("WSA_API_KEY");
if (apiKey == null || apiKey.isBlank()) {
throw new IllegalStateException("Set WSA_API_KEY");
}
var actions = "[{\"action\":\"scrollTo\",\"selector\":\"main\"," +
"\"timeout\":1000,\"block\":\"start\"}]";
var query = "api_key=" + URLEncoder.encode(apiKey, StandardCharsets.UTF_8)
+ "&url=" + URLEncoder.encode("https://example.com/app", StandardCharsets.UTF_8)
+ "&wait_for_css=main"
+ "&js_instructions=" + URLEncoder.encode(actions, StandardCharsets.UTF_8)
+ "&json_response=1";
var request = HttpRequest.newBuilder()
.uri(URI.create("https://api.webscrapingapi.com/v1?" + query))
.timeout(Duration.ofSeconds(120)).GET().build();
var response = HttpClient.newHttpClient()
.send(request, HttpResponse.BodyHandlers.ofString());
if (response.statusCode() >= 400) {
throw new RuntimeException("API status " + response.statusCode());
}
System.out.println(response.body());
}
}
using System.Net.Http;
var apiKey = Environment.GetEnvironmentVariable("WSA_API_KEY");
if (string.IsNullOrWhiteSpace(apiKey))
throw new InvalidOperationException("Set WSA_API_KEY");
var actions = "[{\"action\":\"scrollTo\",\"selector\":\"main\"," +
"\"timeout\":1000,\"block\":\"start\"}]";
var requestUrl = "https://api.webscrapingapi.com/v1?api_key="
+ Uri.EscapeDataString(apiKey)
+ "&url=" + Uri.EscapeDataString("https://example.com/app")
+ "&wait_for_css=main"
+ "&js_instructions=" + Uri.EscapeDataString(actions)
+ "&json_response=1";
using var client = new HttpClient {
Timeout = TimeSpan.FromSeconds(120)
};
var response = await client.GetAsync(requestUrl);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());require "json"
require "net/http"
require "uri"
api_key = ENV["WSA_API_KEY"]
raise "Set WSA_API_KEY" if api_key.nil? || api_key.empty?
uri = URI("https://api.webscrapingapi.com/v1")
uri.query = URI.encode_www_form(
api_key: api_key,
url: "https://example.com/app",
wait_for_css: "main",
js_instructions: [{
action: "scrollTo", selector: "main",
timeout: 1000, block: "start"
}].to_json,
json_response: 1
)
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
http.open_timeout = 10
http.read_timeout = 120
response = http.get(uri.request_uri)
raise "API status #{response.code}" unless response.is_a?(Net::HTTPSuccess)
puts response.bodyOperative Eigentumsform
Was wir betreiben und was Sie kontrollieren
WebScrapingAPI
Ausführung von gehosteten Browseranforderungen
- REST-Anforderungsvalidierung und -ausführung
- Gehostete Browser-Laufzeit mit JavaScript-Rendering
- Proxy-Geolokalisierung, IP-Rotation und IP-Block-Handling
- Dokumentierte Wartezeiten und Anweisungsausführung
- Generierung der angeforderten Ausgabe und Antwortlieferung
- Dokumentierte API-Fehlermeldung
Ihr Team
Quellen- und Datenproduktentscheidungen
- Target Berechtigung, Zweck und Anfragerichtlinie
- Anforderungskonfiguration, Interaktionen und Bereitschaftsbedingungen
- Selektoren, Extraktionsschema und Antwortvalidierung
- Wartungs- und Regressionstests bei Quelländerungen
- Planung, Speicherung, Aufbewahrung und nachgelagerte Nutzung
Page stateDer Kunde legt den Zustand fest; WebScrapingAPI führt die dokumentierten Warte- und Aktionen durch.
Browser-LaufzeitumgebungWebScrapingAPI betreibt die hosted browser-exécution und die hinter ihr stehende anfrageinfrastruktur.
AntwortWebScrapingAPI gibt die ausgewählte Ausgabe oder Fehler zurück; der Kunde bestätigt die Vollständigkeit des Geschäfts.
ExtraktionWebScrapingAPI führt die angebotenen Regeln durch; der Kunde führt die Auswahl-, Schema- und Qualitätskontrollen durch.
Use Browser API only for eligible public pages. Review source terms, applicable requirements, and the Servicevereinbarung für Kunden, then apply appropriate access, retention, and data-use policies.
Use Cases für
Verwenden Sie Browser-API, wenn der gerenderte Zustand die Antwort ändert.
Die Produktauswahl
Ihre Optionen vergleichen
Netzstrecke
Proxys
Infrastructure building blockManaged RetrievalIhr Team führt den HTTP-Client, Browser oder Parser, erneut versuchen Sie die Richtlinie, Validieren und Speichern.
Scraper-API
One page retrievalGeführte BrowseranfrageSenden Sie eine URL für eine verwaltete Seitenanfrage mit optionaler Rendering und dokumentierten Antwortformaten.
Browser-API
Rendered state and interactionGeführte BewertungDefinieren Sie Bereitschaft, unterstützte Aktionen, Kontext und Ausgabe in einer Serverseiten-REST-Anfrage.
Crawl-API
Scoped multi-page collectionOperationelle EntbindungPlanen Sie eine begrenzte Sammlung, wenn die Arbeitsstelle über die entsprechenden berechtigten Seiten statt über eine Browseranfrage erstreckt.
Verwaltete Daten
Data delivered to specificationDefinition von Quellen, Schema, Kadenz, Qualität und Bestimmung, während WebScrapingAPI das wiederkehrende Programm betreibt.
Preisorientierung
Ein Angebot für Ihre Aufgaben erhalten
Beweisen Sie ein stabiles Anforderungsrezept.
Beginnen Sie mit einer repräsentativen dynamischen Seite, dann validieren Sie die kleinste Kombination aus Kontext, Bereitschaft, Aktionen und Ausgabe, die Ihren Anforderungen entspricht.
- Vertreter berechtigt target Set
- Beobachtbarer Bereitschaftszustand
- Kürzeste erforderliche Interaktionssequenz
- Output- und Business-Validierungsvertrag
FAQ
Fragen zum Produkt
Was ist Browser-API?
Browser-API ist eine Serverseiten-REST-Anfrage, die eine berechtigte öffentliche Webseite in einem gehosteten Browser lädt, dokumentierte Wartezeiten und Aktionen anwendet und die gewählte Antwort auf Ihre Anwendung zurückgibt.
Was kann Browser-API zurückgeben?
Die dokumentierten Ausgabeoptionen umfassen Roh-HTML, einen JSON-Umschlag, eine JSON DOM-Repräsentation, vom Kunden definierte extrahierte Felder und einen Screenshot, der als base64 innerhalb der Antwort zurückgegeben wird.
Welche Seitenaktionen werden unterstützt?
Unter den Dokumenten von JavaScript-Anweisungen sind Klick, Klick und Navigation, Scrollen, eingegebenene Werte, Wertzuweisung, Auswahl, Einreichung, Fokus und Warten. Erstellen und testen Sie die kürzeste Sequenz, die den benötigten Zustand erreicht.
Wie kann eine Anfrage auf den richtigen Seitenstatus warten?
Verwenden Sie einen dokumentierten Seitenlebenszykluswert, eine Verzögerung oder einen CSS-Selektor. Sie können wait_until, wait_for, wait_for_css und Aufforderungsebene-Warte nach dem Verhalten von target kombinieren.
Kann ich den Geräte-, Ansichtsfenster- und Standortkontext steuern?
Ja. Unter den dokumentierten Kontrollen sind der Kontext für Desktop-, Mobil- oder Tablet-Geräte, die Fensterbreite und -höhe sowie der unterstützte Kontext für die Anfrage auf Länderebene.
Gibt Browser-API eine Live-Browser-Steuerverbindung frei?
Nr. Browser-API verwendet eine Anfrage-Antwort-REST-Schnittstelle. Ihre Anwendung erklärt unterstützte Wartungen, Aktionen, Kontext und Ausgabe durch Anfrageparameter, dann erhält die ausgewählte Antwort oder ein API-Fehler.
Wem gehören Interaktionsanweisungen und Extraktionsregeln?
WebScrapingAPI führt die hosted browser-ausführung aus und gibt die angeforderte ausgabe zurück. ihr team besitzt target berechtigung, interaktionsanweisungen, selektoren, extraktionsschema, inhaltsvalidierung und wartung der quelleänderung.
Ihre erste Browseranfrage
Ihren Browserablauf planen
Teilen Sie eine Seite, benötigte Aktionen und erwartetes Volumen. Wir helfen Ihnen, den Browser-API-Tarif festzulegen.