As intenções regionais permanecem visíveis
Mantenha o ID da região Yandex e a língua ao lado da página capturada para que as comparações posteriores conservem o seu contexto de mercado.
API de busca Yandex para SERPs locais
Capture o HTML das páginas de busca localizadas do Yandex em uma resposta JSON. Escolha região, idioma, dispositivo e página e aplique suas regras de extração.
Um contrato de captura os compradores podem avaliar
Capture a página de origem e controle a extração
A apresentação é deliberada
Escolha o perfil do dispositivo documentado e o número de página em vez de tratar cada resposta do Yandex como intercâmbio.
O limite de resposta é explícito
Planeje um envelope JSON contendo a carga útil do HTML SERP de origem em vez de assumir um modelo de registro a jusante.
As decisões do esquema ficam com você.
Extrair apenas os campos que seu fluxo de trabalho precisa, versão de que esquema, e decidir como as alterações de página devem ser manuseadas.
- Motoryandex
- Pergunta .pizza
- Regiãolr 213
- Línguaru
- Dispositivodesktop
- Páginap 0
- Janeladentro de 77
Guarda esta impressão digital com a carga útil para que as equipes possam comparar capturas semelhantes e diagnosticar alterações na extracção.
Superfície documentada de Yandex
Capture a página de resultados definida pelo seu contexto regional e de apresentação.
O endpoint do Yandex aceita uma consulta de pesquisa plus contexto opcional. Comece com solicitações representativas para os países, línguas, dispositivos, páginas e janelas de tempo que o aplicativo realmente usará.
ID de localização do Yandex
Use o identificador de região esperado pelo Yandex para influenciar a página de resultados para a localização prevista.
Contexto da solicitação · lrLíngua de pesquisa
Anexe o valor de linguagem documentada à observação e valida-o com o conjunto de região e consulta.
Contexto da solicitação · langProfil do dispositivo
Solicite uma apresentação de desktop, celular ou tablet onde o controle do dispositivo documentado se adapte ao seu fluxo de trabalho.
Contexto da solicitação · dispositivoFiltro de página e tempo
Selecione uma página de resultados baseada em zero e, se necessário, um valor documentado de intervalo de tempo.
Contexto da solicitação · p / dentroParâmetros da solicitação
Configure sua solicitação
O guia de solicitações básicas usa o parâmetro de consulta mostrado abaixo. Adicione contexto opcional apenas quando suporta um produto ou exigência de pesquisa clara.
Pergunta
Passe o texto de pesquisa no campo de Requestas Básicas documentado e espaços de codificação de URL ou caracteres especiais.
Região, língua e dispositivo
Configure o ID da região de localização do Yandex, a linguagem de pesquisa e o perfil documentado do desktop, celular ou tablet.
Paginação e recência
Use p=0 para a primeira página e adicione um valor de tempo suportado, como 77 para as últimas 24 horas ou 1 para as últimas duas semanas.
Resposta à carga de serviço da fonte
Receba um envelope JSON, e depois aplica o seu próprio contrato de extracção.
A API de Pesquisa do Yandex retorna os metadados da resposta e a representação da página fonte. Desenhe o consumidor em torno desse limite antes de adicionar arquivos de armazenamento, monitoramento ou pesquisa derivada.
Resposta à API
Envelope JSON com a carga útil de HTML SERP fonte.
O envelope inclui search_parameters para o contexto da pesquisa submetida e search_results para a carga útil do HTML SERP de origem.
Verifique o status HTTP antes de ler o corpo.
Armazenar apenas o contexto da solicitação e os dados de origem necessários ao seu fluxo de trabalho.
Trate as alterações no layout da página como um evento de extração e esquema.
{
"search_parameters": {
"search_engine": "yandex",
"yandex_url": "https://www.yandex.com/search/?text=pizza",
"query": "pizza"
},
"search_results": "<html>...</html>"
}O seu pedido
Extração e manutenção de esquemas
O seu aplicativo possui extração do HTML devolvido. Sua equipe define os campos derivados, regras de validação, versões de esquema e resposta de manutenção quando o Yandex atualiza sua página.
Uma captura contextual
Da solicitação ao resultado
- 01Defina o contexto da página
Escolha a consulta e adicione a região documentada, idioma, dispositivo, página baseada em zero e entradas de intervalos de tempo que você precisa de observação.
- 02Enviar a solicitação do lado do servidor
Ligue para o endpoint do SERP com uma chave API protegida e motor definido para o yandex.
- 03Validação, extrato e versão
Leia o envelope JSON, preserve o contexto da solicitação e execute o HTML fonte através do processo de extração e esquema da sua equipe.
Integração
Conecte pelo seu servidor
Estes pontos de partida mantêm a chave API em uma variável do ambiente, enviam a consulta Requerências Básicas, usam um tempo de cliente de 120 segundos e tornam explícitos os estados HTTP falhos.
: "${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=yandex" \
--data-urlencode "q=pizza"// engine=yandex; q=pizza
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: "yandex",
q: "pizza",
});
const url = new URL(
"https://serpapi.webscrapingapi.com/v2?" + parameters,
);
const response = await fetch(url, {
signal: AbortSignal.timeout(120_000),
});
if (!response.ok) {
throw new Error("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")
# engine=yandex; q=pizza
response = requests.get(
"https://serpapi.webscrapingapi.com/v2",
params={
"api_key": api_key,
"engine": "yandex",
"q": "pizza",
},
timeout=120,
)
response.raise_for_status()
print(response.json())<?php
// engine=yandex; q=pizza
$apiKey = getenv("WSA_API_KEY");
if ($apiKey === false || $apiKey === "") {
throw new RuntimeException("WSA_API_KEY is required");
}
$parameters = http_build_query([
"api_key" => $apiKey,
"engine" => "yandex",
"q" => "pizza",
]);
$client = curl_init(
"https://serpapi.webscrapingapi.com/v2?" . $parameters
);
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 < 200 || $status >= 300) {
throw new RuntimeException("API status " . $status . ": " . $body);
}
echo $body;package main
import (
"fmt"
"io"
"log"
"net/http"
"net/url"
"os"
"time"
)
func main() {
// engine=yandex; q=pizza
apiKey := os.Getenv("WSA_API_KEY")
if apiKey == "" { panic("WSA_API_KEY is required") }
query := url.Values{
"api_key": {apiKey},
"engine": {"yandex"},
"q": {"pizza"},
}
client := &http.Client{Timeout: 120 * time.Second}
response, err := client.Get(
"https://serpapi.webscrapingapi.com/v2?" + query.Encode(),
)
if err != nil { log.Fatal(err) }
defer response.Body.Close()
body, err := io.ReadAll(response.Body)
if err != nil { log.Fatal(err) }
if response.StatusCode < 200 || response.StatusCode >= 300 {
log.Fatalf("API status %d: %s", response.StatusCode, body)
}
fmt.Println(string(body))
}import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
public final class YandexSearchApiExample {
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";
String query = "api_key=" + URLEncoder.encode(
apiKey, StandardCharsets.UTF_8
) + "&engine=yandex&q=pizza";
var client = HttpClient.newBuilder()
.connectTimeout(Duration.ofSeconds(120))
.build();
var request = HttpRequest.newBuilder(URI.create(endpoint + "?" + query))
.timeout(Duration.ofSeconds(120))
.GET()
.build();
var response = client.send(
request, HttpResponse.BodyHandlers.ofString()
);
if (response.statusCode() < 200 || response.statusCode() >= 300) {
throw new IllegalStateException(
"API status " + response.statusCode()
);
}
System.out.println(response.body());
}
}
}using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
// engine=yandex; q=pizza
var rawApiKey = Environment.GetEnvironmentVariable("WSA_API_KEY");
if (string.IsNullOrWhiteSpace(rawApiKey)) {
throw new InvalidOperationException("WSA_API_KEY is required");
}
var apiKey = rawApiKey;
using var client = new HttpClient {
Timeout = TimeSpan.FromSeconds(120)
};
var parameters = new Dictionary<string, string> {
["api_key"] = apiKey,
["engine"] = "yandex",
["q"] = "pizza"
};
var query = string.Join("&", parameters.Select(item =>
$"{WebUtility.UrlEncode(item.Key)}={WebUtility.UrlEncode(item.Value)}"));
using var response = await client.GetAsync(
"https://serpapi.webscrapingapi.com/v2?" + query
);
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?
# engine=yandex; q=pizza
uri = URI("https://serpapi.webscrapingapi.com/v2")
uri.query = URI.encode_www_form(
api_key: api_key,
engine: "yandex",
q: "pizza"
)
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}: #{response.body}"
end
puts response.body- Ponto final
/v2- Requerido
api_key+engine=yandex+q- Segredo
WSA_API_KEYpermanece do lado do servidor- Consumidor
Verifique o status, e leia JSON
Casos de utilização
Use contextual página de Yandex captura onde a fonte é o ponto de partida certo.
Visível de pesquisaExplore SERP monitoringPresença da marcaExplore brand protectionPesquisa de mercadoExplore market researchPrograma de dadosReview search data
Observação localizada de Yandex
Capture páginas para combinações de consulta controlada, região, idioma, dispositivo e pagination, e depois calcule as métricas definidas pela sua equipe.
Revisão de editores regionais
Extrair os domínios e elementos de página relevantes para um processo de revisão, preservando o contexto original do Yandex.
Paisagens de origem e de tópicos
Construir um esquema de extração definido para os editores, tópicos ou elementos da página de resultados necessários para um resumo de pesquisa.
Registros de pesquisa recorrentes
Defina um esquema explícito, selos de tempo, estados de qualidade e contrato de entrega quando as cargas úteis da fonte de tempo de solicitação não são o produto final.
Selecção do produto
Compare suas opções
Motores múltiplosProduto corrente Acesso à página geral
API SERP família
Compare os contratos de controle e resposta documentados do Google, Bing, DuckDuckGo e Yandex.
Respostas específicas do motorAPI de pesquisa de Yandex
Envie uma consulta Yandex localizada e receba o contexto plus a carga útil do HTML SERP fonte em JSON.
API de scraping
Obter uma página web pública elegível quando o seu target não for representado pelos controles de pesquisa do Yandex.
Resposta à página pública Entrega gerenciadaDados geridos
Mover conjuntos de consultas, cadência, esquema, processo de qualidade e entrega para um programa de dados recorrentes acordado.
Contrato de dados operacionaisAvaliação da produção
Obtenha um orçamento para sua carga de trabalho
Tamanho dos contextos, páginas e frequência juntos.
Questões
Regiões
Dispositivos
Páginas
Frequência
Este é um modelo de avaliação, não uma promessa de faturamento.
FAQ
Perguntas sobre o produto
O que a API de pesquisa do Yandex retorna?
A API de Pesquisa do Yandex retorna um envelope JSON com metadados de solicitação e a carga útil de HTML SERP fonte em search_results. Não define o seu esquema de registro descendente.
Quais valores são necessários para uma solicitação de Yandex?
Envie a chave API do lado do servidor, configure o motor para o yandex e passe a consulta de pesquisa em q. O texto da consulta de codificação de URL quando contém espaços ou caracteres especiais.
Como escolho a região e a língua do Yandex?
Use lr para o ID da região de localização do Yandex e lang para a linguagem de pesquisa. Um domínio do Yandex também pode ser selecionado quando documentado; valida a combinação com pesquisas representativas antes da utilização da produção.
Como funciona a pagination do Yandex?
Use p para a página de resultado. A contagem de páginas começa em 0, então p=0 solicita a primeira página. Mantenha p com o resto do contexto da solicitação ao comparar captures.
Quem mantém a extração da carga útil do Yandex?
A sua aplicação possui extração da carga útil de HTML SERP fonte, e a sua equipe possui o esquema derivado e a sua manutenção à medida que os layouts de páginas do Yandex mudam.
Como meu aplicativo deve lidar com erros de API do Yandex?
Configure um tempo limite explícito para o cliente, inspecione o status HTTP antes de usar o corpo de resposta, retenha conteúdo suficiente para diagnosticar falhas e aplique retemps limitados apenas quando se encaixam no seu fluxo de trabalho.
A tua primeira captura de Yandex .
Planeje sua coleta de dados de busca
Compartilhe buscador, consultas, mercados e frequência. Confirmaremos o formato de resposta e o preço para sua carga de trabalho.