Gérer les pages rendues par le client
Use browser-backed retrieval when required content appears only after page JavaScript has executed.
Review request controlsAPI de navigateur
API de navigateur pour les pages JavaScript
Obtenez du HTML rendu, des champs sélectionnés ou des captures de pages dynamiques. Envoyez les attentes et actions via une API REST ; nous exécutons le navigateur.
- Les attentes de l'ÉtatCycle de vie, retard ou sélecteur
- Actions guidéesCliquez, défilez, tapez, sélectionnez, soumettez
- Context de la demandeAppareil, point de vue, pays
- Sortie sélectionnableHTML, JSON, champs, capture d'écran
Une limite de navigateur plus claire
Collectez des pages rendues sans gérer les navigateurs
Capturez un état de page délibéré
Wait for a lifecycle event, delay, selector, or documented instruction step instead of parsing whatever happens to arrive first.
See the request workflowChoisissez la réponse utile
Return rendered HTML, a JSON response, a JSON DOM, selected fields, or a screenshot for the downstream task.
Compare output optionsVotre demande définitURL · context · readiness · actions · output
WebScrapingAPI est opérationnelHosted browser execution and response delivery
Votre pipeline reçoitOne documented response or explicit error
Demande d' anatomie
Configurez votre requête
Commencez par l'URL target et ajoutez uniquement les contrôles documentés nécessaires pour reproduire la page d'état de vos besoins d'application. Le guide des paramètres API de navigateur.
Context de la demande
Définir comment le navigateur hébergé atteint et encadre la page.
api_key- Autentification côté serveur
url- Le code d'adresse URL est public target
method- Métode de demande Target
body- Le corps facultatif target
country- Contextes pays pris en charge
timeout- Temps maximal de la requête
device- Tableau de bureau, mobile ou tablette
window_width- Largeur de la vue
window_height- Hauteur de la vue
block_resources- Blocage optionnel des ressources
Préparation et actions
Dites à la demande quand la page est prête et ce qu'il faut faire ensuite.
wait_until- État du cycle de vie
wait_for- Délais explicite
wait_for_css- Sélecteur requis
js_instructions- Sequence d'interaction ordonnée
auto_solve- Contrôle d'accès documenté
clickscrollTotyped_valueselectsubmitclick_and_navigateCapture et réponse
Sélectionnez la requête qui doit être renvoyée par le navigateur.
screenshot- Requête de capture d'image
screenshot_options- Portée et dimensions de capture
extract_rules- Règles CSS ou XPath fournies par le client
json_response- Enveloppe de réponse JSON
json_dom- Réprésentation JSON DOM
Utilisez la plus petite recette stable.
Préférer un sélecteur observable ou un état de cycle de vie au lieu d'un retard arbitraire, garder les séquences d'action courtes et valider le contenu retourné en fonction de vos propres exigences commerciales.
Flux de travail de demande
De la requête au résultat
- 01request
Définir le numéro target
Provide the URL, method, country, device, viewport, and timeout required for the test case.
- 02state
Prêt à atteindre
Choose
domcontentloaded,load,networkidle0,networkidle2, a delay, or a selector. - 03interaction
Exécuter des actions
Apply an ordered
js_instructionssequence when the page needs clicks, scrolling, values, selections, or navigation. - 04output
Retour et validation
Receive the requested format or explicit error, then validate content before it enters the downstream system.
- Je préfère .
- Prêt à l'observation
Un sélecteur ou une condition du cycle de vie de la page liée au contenu dont vous avez besoin.
- Je le garde .
- Instructions minimales
Seules les actions nécessaires pour atteindre un état stable et répétable.
- Attends
- Les résultats explicites
L'exécution du navigateur peut toujours échouer, mettre fin ou retourner du contenu qui a besoin d'une validation commerciale.
Contrat de production
Choisissez votre format de sortie
Capturez la page rendue une fois, puis choisissez une sortie documentée qui correspond à un parseur existant, à une étape de validation, à un enregistrement de preuves ou à un flux de travail multimédia.
HTML simple
Retournez le corps de la page rendue pour un processus de partage ou d'archivage que votre équipe exploite.
text/htmlEnveloppe JSON
Envelopper le corps avec une demande documentée et le contexte de réponse target pour inspection.
json_responseDOM de JSON
Recevoir le document de la page comme représentation JSON DOM pour le traversage en aval.
json_domChamps extraites
Exécuter des règles CSS ou XPath définies par le client et retourner le contenu sélectionné.
extract_rulesCapture d'écran
Capturez la page complète ou un élément sélectionné et recevez l'image comme base64.
screenshot- Tu as besoin de la page ?
- Plain HTML or JSON DOM
- Vous avez besoin de contexte ?
- JSON envelope
- Vous avez besoin de champs nommés ?
- Extraction rules
- Vous avez besoin de preuves visuelles ?
- Screenshot
Intégration des développeurs
Connectez-vous depuis votre serveur
Appeler le point final REST depuis votre serveur, garder la clé API hors du code client, paramètres de demande d'encode URL, définir un délai fini, et gérer délibérément les réponses non réussis.
Modèle de requête
Commencez par un état observable.
Ces exemples attendent main Remplacez le sélecteur target et les actions par une séquence validée contre votre propre source éligible.
- Point final
https://api.webscrapingapi.com/v1- Le secret
WSA_API_KEYdans l'environnement du serveur- Prêt à l'emploi
wait_for_css=main- Les actions
- - code JSON
js_instructions - Réponse
- Vérifiez l'état avant de parser
: "${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.bodyPropriété opérationnelle
Ce que nous gérons et ce que vous contrôlez
WebScrapingAPI
Exécution de la demande de navigateur hébergée
- Validation et exécution de la demande REST
- Temps d'exécution du navigateur hébergé avec rendu JavaScript
- Localisation géographique par procuration, rotation IP et traitement de bloc IP
- Attentes documentées et exécution des instructions
- Génération de sortie demandée et livraison de réponse
- Réponse d'erreur d'API documentée
Votre équipe
Décisions sur la source et le produit des données
- Target politique d'éligibilité, de but et de demande
- Configuration, interactions et conditions de préparation de la demande
- Sélecteurs, schéma d'extraction et validation de réponse
- Tests de maintenance et de régression en fonction du changement de source
- Programmer, stocker, conserver et utiliser en aval
État de la pageLe client spécifie l'état; WebScrapingAPI exécute les attentes et actions documentées.
Temps de fonctionnement du navigateurWebScrapingAPI exploite l'exécution du navigateur hébergé et l'infrastructure de requête qui le sous-tend.
RéponseWebScrapingAPI renvoie la sortie ou l'erreur sélectionnée; le client valide l'achèvement de l'entreprise.
ExtraitWebScrapingAPI exécute les règles fournies; le client maintient les sélecteurs, les schémas et les contrôles de qualité.
Use Browser API only for eligible public pages. Review source terms, applicable requirements, and the Accord de service, then apply appropriate access, retention, and data-use policies.
Cas d'utilisation
Utilisez API de navigateur lorsque l'état rendu change la réponse.
Choix de produit
Comparez vos options
Route réseau
Proxys
Infrastructure building blockRécupération géréeVotre équipe exécute le client HTTP, le navigateur ou le parseur, la politique de réessayer, la validation et le stockage.
API de scraping
One page retrievalRequête de navigateur guidéeEnvoyez une URL pour une demande de page gérée avec des formats de rendu et de réponse documentés.
API de navigateur
Rendered state and interactionÉvaluation guidéeDéfinir la préparation, les actions prises en charge, le contexte et la sortie dans une demande REST côté serveur.
API d’exploration
Scoped multi-page collectionLivraison opéréePlanifiez une collection limitée lorsque l'unité de travail couvre des pages éligibles liées plutôt que la demande d'un navigateur.
Données gérées
Data delivered to specificationDéfinir les sources, le schéma, la cadence, la qualité et la destination alors que WebScrapingAPI exploite le programme récurrent.
Orientation des prix
Obtenez un devis adapté à votre charge de travail
Prouvez une recette stable.
Commencez par une page dynamique représentative, puis validez la plus petite combinaison de contexte, de préparation, d'actions et de sortie qui répond à vos besoins.
- Réglage de représentant éligible target
- Condition de préparation observable
- Sequence d'interaction requise la plus courte
- Contrat de validation des produits et des activités
FAQ
Questions sur le produit
Quel est le nombre de API de navigateur ?
API de navigateur est une requête REST du côté du serveur qui charge une page Web publique admissible dans un navigateur hébergé, applique des attentes et des actions documentées et renvoie la réponse sélectionnée à votre application.
Qu'est ce qui peut API de navigateur - Je reviens.
Les options de sortie documentées comprennent HTML brut, une enveloppe JSON, une représentation JSON DOM, des champs extraits définis par le client et une capture d'écran retournée sous forme de base64 à l'intérieur de la réponse.
Quelles actions de page sont prises en charge ?
Les instructions JavaScript documentées comprennent le clic, le clic et la navigation, le défilement, les valeurs typées, l'attribution de valeurs, la sélection, la soumission, le focus et les attentes.
Comment une demande peut-elle attendre l'état de la bonne page ?
Utilisez une valeur de cycle de vie de la page documentée, un retard ou un sélecteur CSS. Vous pouvez combiner wait_until, wait_for, wait_for_css et les attentes au niveau des instructions selon le comportement target.
Puis-je contrôler le dispositif, le port de vue et le contexte de l'emplacement ?
Oui. Les contrôles documentés comprennent le contexte des appareils de bureau, mobiles ou tablettes; la largeur et la hauteur des fenêtres; et le contexte de demande pris en charge au niveau du pays.
API de navigateur expose une connexion en direct avec le navigateur ?
- Je ne sais pas. API de navigateur utilise une interface REST requête-réponse. Votre application déclare les attentes, les actions, le contexte et la sortie pris en charge par le biais des paramètres de requête, puis reçoit la réponse sélectionnée ou une erreur API.
Qui possède les instructions d'interaction et les règles d'extraction ?
WebScrapingAPI exécute l'exécution du navigateur hébergé et renvoie la sortie demandée. Votre équipe possède target l'admissibilité, les instructions d'interaction, les sélecteurs, le schéma d'extraction, la validation du contenu et la maintenance du changement de source.
Votre première demande de navigateur
Planifiez votre parcours de navigateur
Partagez une page, les actions nécessaires et le volume prévu. Nous vous aidons à définir le forfait Browser API.