Construa uma impressão digital precisa de um pedido
Descreva a consulta, o domínio do Google, a localização codificada, a linguagem da interface, o país, o dispositivo, a superfície e a janela de resultados necessários para o fluxo de trabalho.
API de pesquisa do Google para dados do SERP
Colete resultados do Google em JSON estruturado para monitorar posições, pesquisar concorrentes e criar ferramentas de busca. Defina local, idioma, dispositivo e tipo de busca.
From query to usable objects
Monitore a visibilidade nas buscas por mercado
Trabalho com coleções analisadas
Leia metadados documentados e matrizes de resultados em vez de ligar o aplicativo à marcação de apresentação de uma página de pesquisa.
Opção de modelo honestamente
Tratar os módulos de pesquisa como condicionais. A sua presença varia com o contexto da solicitação e a superfície do Google retornada para essa observação.
Mantém possível a análise de igual a igual
Armazenar o contexto da solicitação ao lado dos resultados antes de calcular posições, alterações, cobertura do editor ou sinais específicos do produto.
- Pergunta .melhores sapatos de trilha
- Domíniogoogle.com
- LocalizaçãoUS · local codificado
- Línguaen
- Presentação• móvel · web
- JanelaComeço 0 · número 10
- OutputMetadados + coleções
Armazenar esta impressão digital com a resposta analisada antes de comparar posições, módulos ou editores ao longo do tempo.
Superfícies do Google documentadas
Escolha a superfície de pesquisa antes de projetar o consumidor.
Os resultados web regulares usam o motor do Google sem um selector vertical. Os controles documentados estendem o mesmo modelo de solicitação às superfícies de mídia, comércio e empregos.
Superfície padrão
Pesquisa na Web
Enviar . engine=google e o necessário q - Vai-te embora . tbm Desconfigurado para resultados regulares de pesquisa do Google.
Descoberta visual
Imagens
Configure o selector vertical documentado em TBC =.
Observação de intenção
Vídeos
Configure o selector vertical documentado em tbm=vid.
Cobertura atual
Notícias
Configure o selector vertical documentado em TBC = nova.
Descoberta do produto
Compras
Configure o selector vertical documentado em TBM = loja.
Descoberta de papéis
Trabalhos
Utilize o valor dos empregos documentados ibp=htl;jobs.
Parâmetros da solicitação
Configure sua solicitação
Comece com o parâmetro de consulta necessário. Adicione controles opcionais documentados apenas quando o fluxo de trabalho precisa de uma superfície, apresentação, localização ou janela de resultado específica.
q
As palavras-chave para procurar no Google.
· string necessáriatbm ibp
tbm seleciona imagens, vídeos, notícias ou verticais de compras documentados. ibp Suporta o valor da procura de emprego documentado.
device
Selecione uma apresentação de pesquisa de desktop, celular ou tablet com suporte.
• opcionaldomain
Escolha o domínio do Google usado para a pesquisa.
• opcionaluule
Passe um local codificado do Google para o contexto da pesquisa.
• opcionalhl gl
hl define a linguagem da interface; gl fornece o código do país utilizado para localizar a pesquisa.
start num
start é o resultado compensado para saltar; num solicita o número de resultados em cada página.
Resposta do Google
Projeto em torno de significados estáveis e módulos condicionais.
A resposta documentada carrega metadados de pesquisa e coleções de resultados JSON analisados. Os blocos presentes em uma resposta específica dependem da consulta, local, dispositivo e vertical de pesquisa.
01 · contexto
general
Motor de busca, contagem de resultados, idioma, localização, apresentação, tipo de pesquisa, título de página e campos de timestamp mostrados pelo exemplo de resposta documentada.
02 · pedido de rastreamento
input
Solicitar informações como a URL original e os campos de agente de usuário mostrados no exemplo de resposta documentada.
03 · caminhos de descoberta
navigation
As entradas de navegação devolvidas podem identificar outras superfícies de pesquisa do Google para a consulta.
04 · Resultados analisados
organic[]
Os objetos orgânicos documentados incluem campos como link, display link, título, descrição, rank e rank global quando devolvidos.
Uma solicitação contextual
Da solicitação ao resultado
- 01Enquadrar a observação
Escolha a consulta, a superfície de pesquisa, o domínio do Google, a localização codificada, a língua, o país, o dispositivo e a janela de página necessária pela decisão.
- 02Ligue para o endpoint do lado do servidor
Enviar uma solicitação de GET para
https://serpapi.webscrapingapi.com/v2withapi_key,engine=google, eq. - 03Validação antes da utilização
Inscreva o resultado HTTP, analise o JSON, leia as coleções de seu fluxo de trabalho necessárias e preserve o contexto da solicitação com resultados armazenados.
Pedido sincrono
engine=google
Use o caminho padrão quando o aplicativo deve esperar a resposta atual do Google.
Recuperação em fila
engine=google_async
Envie uma pesquisa no Google e retira a carga útil SERP finalizada mais tarde através da API Snapshot.
Integração
Conecte pelo seu servidor
Mantenha a chave API na configuração do lado do servidor, codifique os valores da consulta, defina um tempo limite explícito e permita resultados HTTP falhos antes de analisar a resposta.
: "${WSA_API_KEY:?WSA_API_KEY is required}"
curl --get --fail-with-body --max-time 120 \
"https://serpapi.webscrapingapi.com/v2" \
--data-urlencode "api_key=$WSA_API_KEY" \
--data-urlencode "engine=google" \
--data-urlencode "q=best trail shoes" \
--data-urlencode "gl=us" \
--data-urlencode "hl=en" \
--data-urlencode "device=mobile"const apiKey = process.env.WSA_API_KEY;
if (!apiKey) throw new Error("WSA_API_KEY is required");
const parameters = new URLSearchParams({
"api_key": apiKey,
"engine": "google",
"q": "best trail shoes",
"gl": "us",
"hl": "en",
"device": "mobile",
});
const response = await fetch(
"https://serpapi.webscrapingapi.com/v2?" + parameters,
{ signal: AbortSignal.timeout(120_000) }
);
if (!response.ok) {
throw new Error("Google Search API status " + response.status);
}
console.log(await response.json());import os
import requests
api_key = os.environ.get("WSA_API_KEY")
if not api_key:
raise RuntimeError("WSA_API_KEY is required")
response = requests.get(
"https://serpapi.webscrapingapi.com/v2",
params={
"api_key": api_key,
"engine": "google",
"q": "best trail shoes",
"gl": "us",
"hl": "en",
"device": "mobile",
},
timeout=120,
)
response.raise_for_status()
print(response.json())<?php
$apiKey = getenv("WSA_API_KEY");
if ($apiKey === false || $apiKey === "") {
throw new RuntimeException("WSA_API_KEY is required");
}
$endpoint = "https://serpapi.webscrapingapi.com/v2"
. "?engine=google"
. "&api_key=" . rawurlencode($apiKey)
. "&q=" . rawurlencode("best trail shoes")
. "&gl=us&hl=en&device=mobile";
$client = curl_init($endpoint);
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("WSA_API_KEY is required") }
endpoint := "https://serpapi.webscrapingapi.com/v2?engine=google" +
"&api_key=" + url.QueryEscape(apiKey) +
"&q=" + url.QueryEscape("best trail shoes") +
"&gl=us&hl=en&device=mobile"
client := &http.Client{Timeout: 120 * time.Second}
response, err := client.Get(endpoint)
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 GoogleSearchApiExample {
public static void main(String[] args) throws Exception {
String apiKey = System.getenv("WSA_API_KEY");
if (apiKey == null || apiKey.isBlank()) {
throw new IllegalStateException("WSA_API_KEY is required");
}
String endpoint = "https://serpapi.webscrapingapi.com/v2"
+ "?engine=google"
+ "&api_key=" + URLEncoder.encode(
apiKey, StandardCharsets.UTF_8)
+ "&q=" + URLEncoder.encode(
"best trail shoes", StandardCharsets.UTF_8)
+ "&gl=us&hl=en&device=mobile";
var request = HttpRequest.newBuilder(URI.create(endpoint))
.timeout(Duration.ofSeconds(120))
.GET().build();
var response = HttpClient.newHttpClient()
.send(request, HttpResponse.BodyHandlers.ofString());
if (response.statusCode() < 200 || response.statusCode() >= 300) {
throw new RuntimeException("API status " + response.statusCode());
}
System.out.println(response.body());
}
}
using System;
using System.Net;
using System.Net.Http;
var rawApiKey = Environment.GetEnvironmentVariable("WSA_API_KEY");
if (string.IsNullOrWhiteSpace(rawApiKey)) {
throw new InvalidOperationException("WSA_API_KEY is required");
}
var apiKey = WebUtility.UrlEncode(rawApiKey);
var query = WebUtility.UrlEncode("best trail shoes");
var endpoint = "https://serpapi.webscrapingapi.com/v2"
+ "?engine=google&api_key=" + apiKey
+ "&q=" + query
+ "&gl=us&hl=en&device=mobile";
using var client = new HttpClient();
client.Timeout = TimeSpan.FromSeconds(120);
var response = await client.GetAsync(endpoint);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());require "net/http"
require "uri"
api_key = ENV["WSA_API_KEY"]
raise "WSA_API_KEY is required" if api_key.nil? || api_key.empty?
api_key = URI.encode_www_form_component(api_key)
query = URI.encode_www_form_component("best trail shoes")
uri = URI("https://serpapi.webscrapingapi.com/v2" +
"?engine=google&api_key=#{api_key}&q=#{query}" +
"&gl=us&hl=en&device=mobile")
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)
unless response.is_a?(Net::HTTPSuccess)
raise "API status #{response.code}"
end
puts response.body- Ponto final
https://serpapi.webscrapingapi.com/v2- Requerido
api_key+engine=google+q- Contexto
gl=us+hl=en+device=mobile- Limite
120 segundos de tempo de espera do cliente e manejo explícito de erros HTTP
Fluxos de trabalho do comprador
Transformar observações comparáveis do Google em sinais específicos do produto.
Inteligência SEOExplore search monitoringVisível da marcaExplore brand protectionPesquisa de mercadoExplore market researchContrato de dados de pesquisaReview search-result data
Monitoramento da posição e do módulo
Compare posições orgânicas devolvidas e módulos opcionais em consultas controladas, locais, dispositivos e janelas de resultados.
Presença de editores e domínios
Observe os domínios devolvidos para grupos de consulta aprovados mantendo regras de ausência e significância dentro do seu aplicativo.
Paisagens de tópicos e fontes
O mapa devolveu editores, títulos e descrições em contextos de pesquisa comparáveis e períodos de revisão.
Registros históricos do SERP
Defina o esquema, a marca de tempo de observação, a impressão digital de solicitação, os estados de validação e o modelo de retenção necessários para além do JSON de tempo de solicitação.
Selecção do produto
Compare suas opções
Acesso à redeProduto corrente Recuperação interativa
Proxies
A sua equipa possui o cliente de busca, a lógica de recuperação, a análise, o modelo de resposta e a manutenção.
Infraestrutura Retorno de páginaAPI de scraping
Solicite uma página pública elegível enquanto o seu aplicativo possui a extração e o seu esquema de fluxo descendente.
API de acesso à webAPI de pesquisa do Google
Envie uma consulta contextual do Google e consuma metadados documentados plus coleções de resultados analisados.
API de navegador
Use uma solicitação REST com suporte do navegador com espera documentada e passos de interação quando os parâmetros da Pesquisa do Google não se encaixem adequadamente.
API de acesso à web Entrega operativaDados geridos
Concordar com o conjunto de consultas, cadência, esquema, processo de qualidade e entrega com WebScrapingAPI.
Programa de dadosAvaliação da produção
Escolha um plano para sua carga de trabalho
Estimar observaçõesnão apenas palavras-chave.
Questões
Contexto
Superfícies
Janela
Frequência
Este é um modelo de planeamento. Os preços atuais e as condições do plano continuam a ser a fonte comercial de verdade.
FAQ
Perguntas sobre o produto
O que a API de Pesquisa do Google retorna?
A API de Pesquisa do Google retorna conteúdo de solicitação e coleções de resultados JSON analisadas. Os resultados orgânicos são documentados, enquanto a navegação e outros módulos de resposta dependem da consulta, local, dispositivo e superfície de pesquisa solicitada.
Que parâmetros de Pesquisa do Google posso controlar?
Use q para a consulta necessária. Os controles opcionais documentados incluem tbm, ibp, dispositivo, domínio, uule, hl, gl, start e num para superfície de pesquisa, apresentação, localização e pagination.
Quais as superfícies de pesquisa do Google são documentadas?
Deixe o tbm desdefinido para pesquisas regulares na web, ou use valores de tbm documentados para imagens, vídeos, notícias e compras. Jobs usa o controle ibp documentado. Valide a forma devolvida para as superfícies que seu aplicativo precisa.
Devem todas as respostas conter os mesmos módulos de resultados?
Não. Os módulos de resultados do Google variam de acordo com a consulta, localização, dispositivo e vertical de pesquisa. Trate os blocos de resposta como opcionais, distingue uma coleção ausente de uma solicitação HTTP falhada e leia apenas os módulos que o aplicativo precisa.
Quando devo usar o google_async?
Use o motor google_async documentado separadamente quando seu fluxo de trabalho deve enviar uma pesquisa do Google e recuperar a carga útil SERP finalizada através da API Snapshot. O motor google padrão é o caminho de solicitação sincrônico mostrado nesta página.
Como devo integrar a API de Pesquisa do Google com segurança?
Mantenha api_key em uma variável de ambiente do servidor, codifique os valores da consulta para a URL, defina um tempo limite explícito e verifique o status HTTP antes de interpretar o JSON. Preserve o contexto da solicitação junto às observações armazenadas.
A sua primeira observação no Google
Teste sua primeira consulta do Google
Use o teste de 100 solicitações do Google para conferir palavras-chave, locais e saída antes de escolher um plano mensal.