Manejar páginas de renderización de cliente
Use browser-backed retrieval when required content appears only after page JavaScript has executed.
Review request controlsAPI de navegador
API de navegador para el
Páginas pesadas en JavaScript
y las interacciones guiadas.
API de navegador es una API REST de solicitud-respuesta: carga una página pública en un navegador alojado, espera el estado que necesita su flujo de trabajo, ejecuta acciones documentadas y devuelve una salida utilizable. No expone una conexión en vivo del navegador y el control.
- Las expectativas del EstadoCiclo de vida, retraso o selector
- Acciones guiadasHaga clic, desplaza, escriba, seleccione, envíe
- Contexto de la solicitudDispositivo, puerto de visión, país
- Salida seleccionableHTML, JSON, campos, capturas de pantalla
Un límite más claro del navegador
Llegar al estado de renderización que necesita sin operar con los trabajadores del navegador.
Describa la solicitud, la condición de preparación, la secuencia de interacción y la salida. WebScrapingAPI opera la ejecución del navegador alojado detrás de ese contrato.
Captura un estado de página deliberado
Wait for a lifecycle event, delay, selector, or documented instruction step instead of parsing whatever happens to arrive first.
See the request workflowElige la respuesta útil
Return rendered HTML, a JSON response, a JSON DOM, selected fields, or a screenshot for the downstream task.
Compare output optionsYour application definesURL · context · readiness · actions · output
WebScrapingAPI operatesHosted browser execution and response delivery
Your pipeline receivesOne documented response or explicit error
Solicitar anatomía
Configurar contexto, preparación, interacción y captura en una sola solicitud.
Comience con la URL target y añada sólo los controles documentados necesarios para reproducir la página que establece las necesidades de su aplicación.Guía de parámetros API de navegador.
Contexto de la solicitud
Definir cómo el navegador alojado llega y enmarca la página.
api_key- Autenticación del lado del servidor
url- El código de URL público target
method- Método de solicitud Target
body- El organismo facultativo target
country- Contexto de país apoyado
timeout- Presupuesto de tiempo de solicitud
device- Descriptor, móvil o tablet
window_width- Ancho de puerto de vista
window_height- Alturas de puerto de vista
block_resources- Bloqueo opcional de recursos
Preparación y acciones
Indique la solicitud cuando la página esté lista y qué hacer a continuación.
wait_until- Estado del ciclo de vida
wait_for- Retraso explícito
wait_for_css- Selector requerido
js_instructions- Secuencia de interacción ordenada
auto_solve- Control de acceso documentado
clickscrollTotyped_valueselectsubmitclick_and_navigateCaptura y respuesta
Seleccione lo que debe devolver la solicitud respaldada por el navegador.
screenshot- Solicitar captura de imagen
screenshot_options- El alcance y las dimensiones de captura
extract_rules- Reglas de CSS o XPath proporcionadas por el cliente
json_response- Envase de respuesta JSON
json_dom- Representación de JSON DOM
Utilice la receta más pequeña y estable.
Prefiere un selector observable o estado del ciclo de vida en lugar de un retraso arbitrario, mantenga las secuencias de acción cortas y valida el contenido devuelto en función de sus propios requisitos comerciales.
Flujo de trabajo de solicitud
Convierta el comportamiento de la página en una receta explícita de solicitud.
El tiempo de ejecución del navegador se administra por WebScrapingAPI. Su aplicación todavía define el estado previsto y decide si el contenido devuelto es apto para su uso.
- 01request
Definir el target
Provide the URL, method, country, device, viewport, and timeout required for the test case.
- 02state
Preparación de alcance
Choose
domcontentloaded,load,networkidle0,networkidle2, a delay, or a selector. - 03interaction
Ejecutar acciones
Apply an ordered
js_instructionssequence when the page needs clicks, scrolling, values, selections, or navigation. - 04output
Regreso y validación
Receive the requested format or explicit error, then validate content before it enters the downstream system.
- Prefer
- Preparación observable
Un selector o condición del ciclo de vida de la página vinculada al contenido que necesita.
- Keep
- Instrucciones mínimas
Sólo las acciones necesarias para alcanzar un estado estable y repetible.
- Expect
- Resultados explícitos
La ejecución del navegador puede fallar, terminar o devolver contenido que necesita validación comercial.
Contrato de producción
Regresa la representación que tu próximo sistema pueda usar.
Captura la página renderizada una vez, luego elija una salida documentada que se adapte a un parser existente, paso de validación, registro de evidencia o flujo de trabajo de medios.
HTML en blanco
Regresa el cuerpo de la página renderizada para un proceso de análisis o archivo que opera tu equipo.
text/htmlEnvase de JSON
Envuelva el cuerpo con una solicitud documentada y un contexto de respuesta target para la inspección.
json_responseDOM de JSON
Recibir el documento de la página como una representación JSON DOM para el cruce en aguas subidas.
json_domCampos extraídos
Ejecutar las reglas CSS o XPath definidas por el cliente y devolver el contenido seleccionado.
extract_rulesImágenes de pantalla
Captura la página completa o un elemento seleccionado y recibe la imagen como base64.
screenshot- ¿Necesitas la página?
- Plain HTML or JSON DOM
- ¿Necesitas contexto de respuesta?
- JSON envelope
- ¿Necesitas campos nombrados?
- Extraction rules
- ¿Necesitas pruebas visuales?
- Screenshot
Integración de desarrolladores
Añadir la recuperación respaldada por el navegador a la pila que ya ejecuta.
Llame al punto final REST desde su servidor, mantenga la clave de API fuera del código del cliente, los parámetros de solicitud de código de URL, establezca un tiempo límite y maneje deliberadamente las respuestas que no tienen éxito.
Recepta de la solicitud
Comience con un estado observable.
Estos ejemplos esperan .main, desplazarse a él, y solicitar una respuesta JSON. reemplazar el target, selector, y acciones con una secuencia validada contra su propia fuente elegible.
- Punto final
https://api.webscrapingapi.com/v1- Secreto
WSA_API_KEYen el entorno del servidor- Preparación
wait_for_css=main- Acciones
- Código JSON
js_instructions - Respuesta
- Verifique el estado antes de analizar
: "${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.bodyPropiedad operativa
Operamos la ejecución del navegador.
Su equipo posee el estado previsto.
Un límite claro hace que la evaluación sea más realista: la infraestructura se mueve detrás de la API, mientras que la elegibilidad de la fuente y la corrección del negocio permanecen con el cliente.
WebScrapingAPI
Ejecución de las solicitudes del navegador alojado
- Validación y ejecución de la solicitud REST
- Tiempo de ejecución del navegador alojado con renderización de JavaScript
- Geolocalización por proxy, rotación de IP y manejo de bloques de IP
- Esperadas documentadas y ejecución de instrucciones
- Generación de salida y entrega de respuesta solicitadas
- Respuesta de error de API documentada
Su equipo
Decisiones sobre la fuente y el producto de los datos
- Target Política de elegibilidad, finalidad y solicitud
- Configuración, interacciones y condiciones de preparación de las solicitudes
- Selectores, esquema de extracción y validación de respuesta
- Pruebas de mantenimiento y regresión de cambio de fuente
- Programación, almacenamiento, retención y uso a continuación
Estado de la páginaCustomer specifies the state; WebScrapingAPI runs the documented waits and actions.
Tiempo de ejecución del navegadorWebScrapingAPI operates hosted browser execution and the request infrastructure behind it.
RespuestaWebScrapingAPI returns the selected output or error; the customer validates business completeness.
ExtracciónWebScrapingAPI executes supplied rules; the customer maintains selectors, schema, and quality checks.
Use Browser API only for eligible public pages. Review source terms, applicable requirements, and the Acuerdo de servicio, then apply appropriate access, retention, and data-use policies.
Casos de uso
Utilice API de navegador cuando el estado renderizado cambie la respuesta.
API de navegador suministra la captura de la página controlada. Su sistema en el flujo posterior convierte esa respuesta en una observación, alerta, resultado de prueba, registro o elemento de evidencia.
Selección de producto
Elige el límite de operación
sus necesidades de carga de trabajo.
API de navegador es un producto de ejecución de navegador basado en peticiones. No expone una conexión en vivo de control del navegador y no reemplaza completamente un programa de entrega Datos gestionados.
Ruta de la red
Los representantes
Infrastructure building blockRecuperación gestionadaSu equipo ejecuta el cliente HTTP, navegador o parser, retest política, validación y almacenamiento.
API de scraping
One page retrievalSolicitud de navegador guiadoEnvía una URL para una solicitud de página gestionada con formato de representación opcional y respuesta documentada.
API de navegador
Rendered state and interactionEvaluamiento guiadoDefinir la preparación, las acciones soportadas, el contexto y la salida en una solicitud REST del lado del servidor.
API de rastreo
Scoped multi-page collectionEntrega operativaPlanifique una colección limitada cuando la unidad de trabajo abarca páginas elegibles relacionadas en lugar de una solicitud de navegador.
Datos gestionados
Data delivered to specificationDefine las fuentes, esquema, cadencia, calidad y destino mientras WebScrapingAPI opera el programa recurrente.
Orientación de precios
Evaluar los estados reales de la página
sus necesidades de trabajo de producción.
La evaluación de los precios actuales es la fuente de la verdad.Una evaluación útil mide representativa targets, las expectativas, acciones, salidas, errores y tiempos de esperano sólo un recuento de solicitudes genéricas.
Prueba una receta estable de solicitud.
Comience con una página dinámica representativa, luego valida la combinación más pequeña de contexto, preparación, acciones y salida que cumpla con sus requisitos.
- El grupo de representantes elegibles target
- Condición de preparación observable
- Secuencia de interacción requerida más corta
- Contrato de producción y validación de la empresa
FAQ
API de navegador preguntas para una evaluación fundamentada.
Confirme primero el límite del producto, luego use la documentación actual para los valores de parámetros, la sintaxis de acción y el manejo de errores.
¿Qué es API de navegador?
API de navegador es una solicitud REST del lado del servidor que carga una página web pública elegible en un navegador alojado, aplica espera y acciones documentadas y devuelve la respuesta seleccionada a su aplicación.
¿Cuándo debería usar el API de navegador?
Utilice API de navegador cuando el target dependa de JavaScript del lado del cliente, un estado renderizado particular o una secuencia guiada como hacer clic, desplazarse, escribir, seleccionar o enviar antes de capturar.
¿Qué puede devolver API de navegador?
Las opciones de salida documentadas incluyen HTML crudo, un envase JSON, una representación JSON DOM, campos extraídos definidos por el cliente y una captura de pantalla devuelta como base64 dentro de la respuesta.
¿Qué acciones de página son compatibles?
Las instrucciones de JavaScript documentadas incluyen hacer clic, hacer clic y navegar, desplazarse, escribir valores, asignar valores, seleccionar, enviar, enfocar y esperar. Construir y probar la secuencia más corta que alcance el estado que necesita.
¿Cómo puede una solicitud esperar el estado de la página correcta?
Utilice un valor de ciclo de vida de página documentado, un retraso o un selector CSS. Puede combinar wait_until, wait_for, wait_for_css y espera a nivel de instrucciones de acuerdo con el comportamiento target.
¿Puedo controlar el dispositivo, el puerto de vista y el contexto de la ubicación?
Sí. Los controles documentados incluyen el contexto de un dispositivo de escritorio, móvil o tablet; ancho y altura de la ventana; y el contexto de solicitud de nivel de país soportado.
¿Puede API de navegador capturar capturas de pantalla?
Sí. Solicite una captura de pantalla y use las opciones de captura de pantalla documentadas para capturar y emitir dimensiones de página completa o selector. El contenido de la captura de pantalla se devuelve como base64 en la respuesta.
¿Exponerá API de navegador una conexión en vivo del control del navegador?
No API de navegador utiliza una interfaz REST de solicitud-respuesta. Su aplicación declara las esperas, acciones, contexto y salida compatibles a través de los parámetros de solicitud, luego recibe la respuesta seleccionada o un error de API.
¿Quién es el dueño de las instrucciones de interacción y las reglas de extracción?
WebScrapingAPI ejecuta la ejecución del navegador alojado y devuelve la salida solicitada. Su equipo posee target elegibilidad, instrucciones de interacción, selectores, esquema de extracción, validación de contenido y mantenimiento de cambio de fuente.
¿En qué se diferencia el API de navegador del API de scraping y del Datos gestionados?
API de scraping se ajusta a una recuperación de página gestionada con renderización opcional. API de navegador agrega controles explícitos de estado de página e interacción a una solicitud REST. Datos gestionados mueve la recurrente recopilación, extracción, calidad y entrega en un programa operado.
Su primera solicitud de navegador
Convierta una página dinámica en una solicitud repetible.
Comience a ser auto-servido, o traiga el perfil de target comportamiento, contexto, estado requerido, salida y solicitud esperada para una revisión de producción.