Manusear páginas de renderização do cliente
Use browser-backed retrieval when required content appears only after page JavaScript has executed.
Review request controlsAPI de navegador
API do navegador para páginas com JavaScript
Obtenha HTML renderizado, campos selecionados ou capturas de páginas dinâmicas. Envie esperas e ações por uma API REST; nós executamos o navegador.
- Esperadas por EstadoCiclo de vida, atraso ou selector
- Ações orientadasClique, rolem, digite, selecione, envie
- Contexto da solicitaçãoDispositivo, ponto de vista, país
- Saída selecionávelHTML, JSON, campos, captura de tela
Um limite mais claro do navegador
Colete páginas renderizadas sem operar navegadores
Capturar um 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 workflowEscolha a resposta útil
Return rendered HTML, a JSON response, a JSON DOM, selected fields, or a screenshot for the downstream task.
Compare output optionsA sua candidatura defineURL · context · readiness · actions · output
WebScrapingAPI operaHosted browser execution and response delivery
O seu gasoduto recebe .One documented response or explicit error
Solicitação de anatomia
Configure sua solicitação
Comece com o URL target e adicione apenas os controles documentados necessários para reproduzir a página de estado das necessidades da sua aplicação. API de navegador guia de parâmetros.
Contexto da solicitação
Defina como o navegador hospedado atinge e enquadra a página.
api_key- Autenticação do lado do servidor
url- Publicação codificada por URL target
method- Método de pedido Target
body- O corpo facultativo target
country- Contexto de país apoiado
timeout- Limite de tempo da solicitação
device- Computador de trabalho, celular ou tablet
window_width- Largura do ponto de vista
window_height- Altura do ponto de vista
block_resources- Bloqueio opcional de recursos
Preparação e acções
Diga o pedido quando a página estiver pronta e o que fazer a seguir.
wait_until- Estado do ciclo de vida
wait_for- O atraso explícito
wait_for_css- Selector necessário
js_instructions- Seqüência de interação ordenada
auto_solve- Controle de acesso documentado
clickscrollTotyped_valueselectsubmitclick_and_navigateCaptura e resposta
Selecione o que a solicitação apoiada pelo navegador deve devolver.
screenshot- Solicitar captura de imagem
screenshot_options- O alcance e as dimensões da captura
extract_rules- Regras de CSS ou XPath fornecidas pelo cliente
json_response- Envelope de resposta JSON
json_dom- Representação JSON DOM
Use a receita mais pequena e estável.
Prefira um selector observável ou estado do ciclo de vida em vez de um atraso arbitrário, mantenha as sequências de ação curtas e valida o conteúdo devolvido em função das suas próprias exigências comerciais.
Fluxo de trabalho de solicitação
Da solicitação ao resultado
- 01request
Define o número de referência target
Provide the URL, method, country, device, viewport, and timeout required for the test case.
- 02state
Preparação de alcance
Choose
domcontentloaded,load,networkidle0,networkidle2, a delay, or a selector. - 03interaction
Execução de acções
Apply an ordered
js_instructionssequence when the page needs clicks, scrolling, values, selections, or navigation. - 04output
Retorno e validação
Receive the requested format or explicit error, then validate content before it enters the downstream system.
- Prefiro .
- Preparação observável
Um selector ou condição de ciclo de vida da página ligada ao conteúdo que você precisa.
- - Não .
- Instruções mínimas
Apenas as ações necessárias para alcançar um estado estável e repetível.
- Esperem .
- Resultados explícitos
A execução do navegador ainda pode falhar, parar ou devolver conteúdo que precisa de validação comercial.
Contrato de produção
Escolha seu formato de saída
Capture a página renderada uma vez, e depois escolha uma saída documentada que se encaixa em um parser existente, passo de validação, registro de evidências ou fluxo de trabalho de mídia.
HTML simples
Retorna o corpo da página representada para um processo de análise ou arquivo que a sua equipe opera.
text/htmlEnvelope JSON
Envolver o corpo com um pedido documentado e um contexto de resposta target para inspeção.
json_responseJSON DOM
Receba o documento da página como uma representação JSON DOM para transmissão a jusante.
json_domCampos extraídos
Execute regras CSS ou XPath definidas pelo cliente e retorna o conteúdo selecionado.
extract_rulesImagem de tela
Capture a página inteira ou um elemento selecionado e receba a imagem como base64.
screenshot- Precisas da página?
- Plain HTML or JSON DOM
- Precisas de contexto de resposta?
- JSON envelope
- Precisas de campos nomeados?
- Extraction rules
- Precisas de provas visuais?
- Screenshot
Integração dos desenvolvedores
Conecte pelo seu servidor
Ligue para o endpoint REST do seu servidor, mantenha a chave API fora do código do cliente, dos parâmetros de solicitação de codificação de URL, defina um prazo finito e maneje deliberadamente as respostas que não tiverem sucesso.
Modelo de solicitação
Comece com um estado observável.
Estes exemplos esperam . main Replaça o selector target, e ações com uma sequência validada contra a sua própria fonte elegível.
- Ponto final
https://api.webscrapingapi.com/v1- Segredo
WSA_API_KEYno ambiente do servidor- Preparação
wait_for_css=main- Ações
- Código JSON
js_instructions - Resposta
- Verificar o estado antes de paralisar
: "${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.bodyPropriedade operacional
O que gerenciamos e o que você controla
WebScrapingAPI
Execução de solicitações de navegador hospedado
- Validação e execução do pedido REST
- Tempo de execução do navegador hospedado com o JavaScript
- Geolocalização por proxy, rotação IP e manuseio de blocos IP
- Esperadas documentadas e execução de instruções
- Geração de saída e entrega de resposta solicitadas
- Resposta de erro de API documentada
Sua equipe
Decisão sobre a fonte e os produtos de dados
- Target Política de elegibilidade, finalidade e pedido
- Configuração, interações e condições de preparação de pedido
- Selectores, esquema de extração e validação de resposta
- Testes de manutenção e regressão de mudança de fonte
- Programação, armazenamento, retenção e utilização posterior
Estado da páginaO cliente especifica o estado; WebScrapingAPI executa as ações e as esperanças documentadas.
Tempo de execução do navegadorWebScrapingAPI opera execução de navegador hospedado e a infraestrutura de solicitação por trás dele.
RespostaWebScrapingAPI retorna a saída ou erro selecionados; o cliente valida a integridade do negócio.
ExtraçãoWebScrapingAPI executa as regras fornecidas; o cliente mantém selectores, esquemas e verificações de qualidade.
Use Browser API only for eligible public pages. Review source terms, applicable requirements, and the Acordo de serviço, then apply appropriate access, retention, and data-use policies.
Casos de utilização
Use API de navegador quando o estado de renderização altera a resposta.
Selecção do produto
Compare suas opções
Rota da rede
Proxies
Infrastructure building blockRecuperação gerenciadaA sua equipe executa o cliente HTTP, navegador ou parcer, política de retest, validação e armazenamento.
API de scraping
One page retrievalRequisito de navegador guiadoEnviar um URL para uma solicitação de página gerenciada com renderização opcional e formatos de resposta documentados.
API de navegador
Rendered state and interactionAvaliação guiadaDefina a prontidão, as ações suportadas, o contexto e a saída em uma solicitação REST do lado do servidor.
API de rastreamento
Scoped multi-page collectionEntrega operativaPlanejar uma coleção limitada quando a unidade de trabalho abrange páginas elegíveis relacionadas em vez de uma solicitação de navegador.
Dados geridos
Data delivered to specificationDefina fontes, esquema, cadência, qualidade e destino enquanto WebScrapingAPI opera o programa recorrente.
Orientação dos preços
Obtenha um orçamento para sua carga de trabalho
Prova uma receita de pedido estável.
Comece com uma página dinâmica representativa, e depois valida a menor combinação de contexto, prontidão, ações e saída que atenda aos seus requisitos.
- Set de representantes elegíveis target
- Condição de prontidão observável
- Seqüência de interação mais curta necessária
- Contrato de produção e de validação de negócios
FAQ
Perguntas sobre o produto
O que é API de navegador?
API de navegador é um pedido REST do lado do servidor que carrega uma página web pública elegível em um navegador hospedado, aplica espera e ações documentadas e retorna a resposta selecionada para o seu aplicativo.
O que pode API de navegador - Voltar?
As opções de saída documentadas incluem HTML bruto, um envelope JSON, uma representação JSON DOM, campos extraídos definidos pelo cliente e uma captura de tela devolvida como base64 dentro da resposta.
Quais as ações de página são suportadas?
As instruções JavaScript documentadas incluem clicar, clicar e navegar, rolar, valores digitalizados, atribuição de valores, seleção, submissão, foco e espera.
Como um pedido pode esperar para o estado da página certa?
Use um valor de ciclo de vida da página documentado, um atraso ou um selector CSS. Você pode combinar wait_until, wait_for, wait_for_css e espera de nível de instrução de acordo com o comportamento target.
Posso controlar o dispositivo, o ponto de vista e o contexto da localização?
Sim. Os controles documentados incluem conteúdo de desktop, dispositivo móvel ou tablet; largura e altura da janela; e conteúdo de solicitação de nível de país suportado.
O API de navegador expõe uma conexão ao vivo do navegador?
No API de navegador usa uma interface REST de solicitação-resposta. A sua aplicação declara as esperanças, ações, contexto e saída suportados através dos parâmetros de solicitação, e recebe a resposta selecionada ou um erro da API.
Quem é o dono das instruções de interação e das regras de extracção?
WebScrapingAPI executa a execução do navegador hospedado e retorna a saída solicitada. Sua equipe possui target elegibilidade, instruções de interação, selectores, esquema de extração, validação de conteúdo e manutenção de mudança de fonte.
Seu primeiro pedido de navegador
Planeje seu fluxo de navegador
Compartilhe uma página, as ações necessárias e o volume esperado. Ajudaremos a definir o plano do Browser API.