Intégration simple du côté serveur
Begin with api_key and a URL-encoded url. Add method, location, rendering, response, or asynchronous options only when the workload requires them.
API de scraping
Scraper API pour les pages web publiques
Envoyez une URL et recevez du HTML, du JSON ou des champs sélectionnés. Nous gérons les proxys, les nouvelles tentatives et le rendu JavaScript optionnel.
- api_key + urlLa moindre demande valide
- Routage géréRetour par procuration et gestion des accès
- render_js facultatifRendering du navigateur lorsque cela est nécessaire
- Corps · JSON · sélecteursDes choix de réponse documentés
Une demande gérée
Obtenez des pages sans gérer l’infrastructure de récupération
Traitement de l'accès géré
WebScrapingAPI operates proxy routing, rotation, access-handling strategies, and internal target retries behind the API request.
Review managed featuresDes choix de réponse documentés
Return the page body, a JSON envelope, a JSON DOM, customer-defined selected fields, or an explicit documented error state.
Review response formatsVotre demande prévoitTarget URL + request context
WebScrapingAPI est opérationnelRouting + access handling + rendering
Votre demande est reçueBody + JSON + selected fields
Fonctions d'accès automatisé
Mettre le travail de récupération répétitif derrière une seule demande API de scraping.
Configurez le contexte dont vous avez besoin. WebScrapingAPI exploite l'infrastructure d'accès de support tout en gardant les échecs visibles à votre client.
01
Routage et rotation par procuration
Le service sélectionne et exploite le parcours de proxy derrière chaque contexte de demande pris en charge.
02
Traitement et retrait des accès
Les stratégies d'accès automatisées et les tentatives internes target réduisent l'infrastructure à exécuter pour votre application.
03
Résultats d'accès observés
Les erreurs de validation, d'accès, de taux et de service restent explicites afin que votre application puisse traiter délibérément les demandes infructueuses.
04
Rendering JavaScript en option
Réglage render_js=1 lorsque le target a besoin d'une exécution du côté client avant que la réponse de la page ne soit retournée.
05
Contextes géographiques des demandes
Demandez un pays documenté et un contexte de ville, d'État ou d'ASN pris en charge lorsque l'emplacement affecte la réponse.
06
Contrôles de demande et de sortie
Utilisez des méthodes prises en charge, un corps facultatif, un délai de réception, des modes de récupération asynchrone, des modes JSON ou des règles d'extraction.
Conception de la réponse
Retournez le niveau de réponse que votre flux de travail peut utiliser.
Gardez le corps de la page, enveloppez-le de métadonnées de demande, exécutez des sélecteurs à la limite de l'API ou récupérez un résultat en file d'attente plus tard.
Réponse de page brute
Utilisez le corps de page par défaut avec un parseur existant.
Enveloppe JSON
Organisme d'inspection, target en-têtes, état initial, type, coût et métadonnées.
champs sélectionnés
Exécuter des sélecteurs CSS ou XPath appartenant au client pour le texte, le HTML, les attributs, les tables ou les enregistrements encastrés.
Retour en file d'attente
Envoyer le travail de manière asynchrone et récupérer la réponse complète en utilisant son identifiant.
Limite d'extraction:WebScrapingAPI exécute les règles fournies. Votre équipe possède le schéma, les sélecteurs, la validation du domaine d'activité et la maintenance du changement de source. Choisissez API de données ou Données gérées lorsque ces obligations doivent passer à WebScrapingAPI.
Comment ça marche
De la requête au résultat
- 01Envoyez la demande
Fournir la clé API, target URL, et uniquement le contexte documenté ou les options de sortie dont la charge de travail a besoin.
- 02WebScrapingAPI récupère la page
Le service valide la demande, exploite le routage proxy, applique la gestion de l'accès et les tentatives internes et rend JavaScript lorsque cela est demandé.
- 03Recevez la réponse
Utilisez le corps de la page retournée, l'enveloppe JSON, les champs sélectionnés ou l'erreur documentée dans votre application existante.
- Métadonnées de la requête
- Les en-têtes de réponse résolus et les en-têtes de réponse scraper sont disponibles par le biais de titres de réponse documentés.
- Contextes d'utilisation
- L'utilisation des crédits par appel et la consommation actuelle peuvent être vérifiées par l'intermédiaire des en-têtes documentés préfichés par l'ASM.
- Contrats d'erreur
- Les erreurs de validation, d'accès, de taux et de service restent des entrées explicites pour la gestion du côté client.
Intégration des développeurs
Connectez-vous depuis votre serveur
Gardez la clé API côté serveur, encodez l'URL target, commencez par une demande de base, et ajoutez le rendu, la géographie ou l'extraction seulement lorsque la charge de travail le nécessite.
01 · résumé de l'intégration
Commencez par la plus petite demande valide.
Envoyez-moi . api_key et une URL codée url - Ajouter render_js=1, le contexte géographique, un mode de réponse ou des règles d'extraction uniquement lorsque les target et le flux de travail en aval en ont besoin.
- Les secrets
- Je le garde .
WSA_API_KEYserver-side - Target
- L'adresse URL est codée par chaque URL target
- Réponse
- Inspecter l'état et le type avant de parser
- Les échecs
- Utilisez une sauvegarde limitée pour les états rétroactifs
curl --get --fail-with-body --max-time 120 \
"https://api.webscrapingapi.com/v2" \
--data-urlencode "api_key=$WSA_API_KEY" \
--data-urlencode "url=https://example.com/public-page" \
--data-urlencode "json_response=1"import os
import requests
response = requests.get(
"https://api.webscrapingapi.com/v2",
params={
"api_key": os.environ["WSA_API_KEY"],
"url": "https://example.com/public-page",
"json_response": 1,
},
timeout=120,
)
response.raise_for_status()
print(response.json())const params = new URLSearchParams({
api_key: process.env.WSA_API_KEY,
url: "https://example.com/public-page",
json_response: "1",
});
const response = await fetch(
"https://api.webscrapingapi.com/v2?" + params,
{ signal: AbortSignal.timeout(120_000) }
);
if (!response.ok) throw new Error("API status " + response.status);
console.log(await response.json());<?php
$query = http_build_query([
"api_key" => getenv("WSA_API_KEY"),
"url" => "https://example.com/public-page",
"json_response" => 1,
]);
$client = curl_init("https://api.webscrapingapi.com/v2?" . $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() {
params := url.Values{}
params.Add("api_key", os.Getenv("WSA_API_KEY"))
params.Add("url", "https://example.com/public-page")
params.Add("json_response", "1")
client := &http.Client{Timeout: 120 * time.Second}
response, err := client.Get(
"https://api.webscrapingapi.com/v2?" + 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;
String query = "api_key=" + URLEncoder.encode(
System.getenv("WSA_API_KEY"), StandardCharsets.UTF_8
) + "&url=" + URLEncoder.encode(
"https://example.com/public-page", StandardCharsets.UTF_8
) + "&json_response=1";
var request = HttpRequest.newBuilder()
.uri(URI.create("https://api.webscrapingapi.com/v2?" + 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;
var apiKey = WebUtility.UrlEncode(
Environment.GetEnvironmentVariable("WSA_API_KEY")
);
var target = WebUtility.UrlEncode(
"https://example.com/public-page"
);
var requestUrl =
"https://api.webscrapingapi.com/v2?api_key=" + apiKey +
"&url=" + target + "&json_response=1";
using var client = new HttpClient();
client.Timeout = TimeSpan.FromSeconds(120);
var response = await client.GetAsync(requestUrl);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());require "net/http"
require "uri"
uri = URI("https://api.webscrapingapi.com/v2")
uri.query = URI.encode_www_form(
api_key: ENV.fetch("WSA_API_KEY"),
url: "https://example.com/public-page",
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
Infrastructure de demande gérée
- Validation et exécution des demandes d'API
- Routage et rotation par procuration
- Traitement automatisé des accès et essais internes target
- Rendering optionnel pris en charge par le navigateur
- Réponse et livraison d'erreurs documentées
Votre équipe
Décisions sur la source et le produit des données
- Target politique d'éligibilité, d'utilisation prévue et de demande
- URL, méthode, contexte, délai et options de sortie
- Gestion des défaillances au niveau de l'API et validation des activités
- Extraction en aval, entretien du sélecteur et stockage
- Programmer, généalogie, conservation et utilisation en aval
Source et butLe client définit les sources admissibles et l'utilisation prévue.
Spécification de la requêteLe client configure la demande documentée; WebScrapingAPI la valide et l'exécute.
Couche d'accèsWebScrapingAPI exploite le routage par procuration, la gestion des accès, les tentatives internes et le rendu optionnel.
RéponseWebScrapingAPI renvoie la sortie demandée ou l'erreur documentée; le client valide le contenu de son application.
ExtraitWebScrapingAPI exécute les règles fournies; le client possède des sélecteurs, des schémas et une maintenance de changement.
Opération en avalLe client possède la planification, le stockage, la surveillance, la conservation et les décisions.
Use the service only for eligible public webpages. Review source terms, applicable requirements, and the Accord de service, then apply appropriate request, retention, and data-use policies.
Cas d'utilisation
Utilisez la page retournée à l'intérieur des flux de travail qui nécessitent encore une logique personnalisée.
Choix de produit
Comparez vos options
Infrastructure de proxys
Proxys
Maximum request-level controlAPI d'accès au WebVous exploitez le client HTTP, la politique de demande, les retries, l'analyse et le stockage. WebScrapingAPI fournit le parcours réseau.
API de scraping
One managed page requestAPI d'accès au WebFournir une URL et des options de demande. WebScrapingAPI opère la récupération et renvoie le corps de la page ou la sortie documentée.
API de navigateur
Guided browser requestAPI d'accès au WebEnvoyez une demande REST avec support de navigateur avec des attentes, des interactions, des étapes de navigation et des commandes de sortie documentées.
API SERP
Search-result recordsÉvaluation guidéeEnvoyer des paramètres de recherche et recevoir des résultats structurés des moteurs de recherche pris en charge.
API d’exploration
Scoped page collectionAPI structuréeÉvaluer une collection de plusieurs pages limitée lorsque l'unité de travail couvre des pages connexes plutôt que d'une seule demande.
API de données
Maintained structured recordsLivraison géréeRechercher une source prise en charge alors que WebScrapingAPI exploite l'accès, l'extraction spécifique target et la maintenance du parseur.
Données gérées
Recurring data deliveryDéfinir les sources, le schéma, la cadence, la qualité et la destination alors que WebScrapingAPI exploite le programme contracté.
Orientation des prix
Choisissez un forfait adapté à votre charge de travail
Évaluation à l'auto-service
Mettre une demande de représentation dans l'API.
Commencez par le chemin HTTP de base, puis testez seulement les commandes que votre mélange de production target exige.
- Les adresses URL représentatives et les méthodes target
- Mix de requêtes statiques par rapport à celles rendues par le navigateur
- Géographie, délai et exigences de réponse
- États d'erreur observés et politique de réessayer du client
FAQ
Questions sur le produit
Quel est le nombre de API de scraping ?
API de scraping est un point final de demande côté serveur qui récupère une page Web publique admissible tandis que WebScrapingAPI exploite l'infrastructure d'accès derrière la demande. Votre application fournit l'URL et les options documentées, puis reçoit la réponse de la page demandée.
Qu'est-ce que le API de scraping est revenu ?
La réponse par défaut est le corps de page récupéré. Les options documentées peuvent renvoyer une enveloppe JSON, une représentation JSON DOM, des champs sélectionnés avec des règles d'extraction ou un résultat asynchrone que votre application récupère plus tard.
API de scraping rend JavaScript est-il rendu ?
Oui. Définir render_js=1 lorsqu'une page nécessite une exécution JavaScript du côté client avant que la réponse ne soit retournée. Utilisez API de navigateur lorsque le flux de travail nécessite une séquence documentée d'interactions avec le navigateur, d'attentes d'état de page, de clics ou d'étapes de navigation.
Quelles méthodes HTTP sont prises en charge ?
API de scraping prend en charge les demandes GET, POST, PUT et PATCH. Incluez un corps de demande lorsque la méthode sélectionnée et le flux de travail target en ont besoin.
Puis-je demander un contenu spécifique à l'emplacement?
Les contrôles documentés comprennent le pays et le contexte de la ville, de l'État ou de l'ASN pris en charge. La disponibilité exacte peut dépendre du plan, de la géographie et du parcours actuels, confirmez donc les emplacements requis par votre charge de travail.
Le nombre de champs sélectionnés peut-il être renvoyé par API de scraping ?
Oui. Les règles d'extraction CSS ou XPath fournies par le client peuvent renvoyer du texte sélectionné, du HTML, des attributs, des tables, des listes ou des enregistrements encastrés. Votre équipe possède les sélecteurs, le schéma, la validation et la maintenance de changement de source pour ces règles.
Les requêtes peuvent-elles être exécutées de manière asynchrone ?
Oui. Faites la queue d'une demande avec l'option documentée asynchrone, conservez l'identifiant retourné et récupérez le résultat complété plus tard en passant cet identifiant sous le nom de snapshot_id.
Comment ma demande doit-elle traiter les demandes qui ne réussissent pas ?
Inspectez l'état HTTP documenté et le corps d'erreur, utilisez une reprise et un backoff limités le cas échéant et distinguer une défaillance de l'API du contenu présent mais incomplet pour votre schéma d'entreprise.
Votre première demande
Testez votre première requête de page
Utilisez l’essai gratuit sur vos URL, puis choisissez un forfait selon le volume de requêtes et les options nécessaires.