La intención regional se mantiene visible
Mantenga el ID de la región Yandex y el idioma junto a la página capturada para que las comparaciones posteriores conserven su contexto de mercado.
API de búsqueda de Yandex para SERPs locales
Captura el HTML de páginas de búsqueda localizadas de Yandex en una respuesta JSON. Elige región, idioma, dispositivo y página y aplica tus reglas de extracción.
Los compradores de un contrato de captura pueden evaluar
Captura la página de origen y controla la extracción
La presentación es deliberada
Elija el perfil de dispositivo documentado y el número de página en lugar de tratar cada respuesta de Yandex como intercambiable.
El límite de respuesta es explícito
Planifique un envase JSON que contenga la carga útil de HTML SERP fuente en lugar de asumir un modelo de registro en aguas subyacentes.
Las decisiones del esquema se quedan con usted
Extraer sólo los campos que su flujo de trabajo necesita, versión de ese esquema, y decidir cómo se deben manejar los cambios de página.
- El motoryandex
- Pregunta .pizza
- Regiónlr 213
- El lenguajeru
- Dispositivodesktop
- Páginap 0
- Ventanadentro de los 77
Guarde esta huella con la carga útil para que los equipos puedan comparar capturas similares y diagnosticar cambios en la extracción.
Superficie documentada de Yandex
Captura la página de resultados definida por su contexto regional y de presentación.
El punto final de Yandex acepta una consulta de búsqueda plus contexto opcional. Comience con solicitudes representativas para los países, idiomas, dispositivos, páginas y ventanas de tiempo que su aplicación realmente utilizará.
Identificación de ubicación de Yandex
Utilice el identificador de región esperado por Yandex para influir en la página de resultados para la ubicación prevista.
Contexto de la solicitud · lrLenguaje de búsqueda
Anexe el valor de lenguaje documentado a la observación y valida con la región y el conjunto de consultas.
Contexto de la solicitud · langProfil del dispositivo
Solicite una presentación de escritorio, móvil o tableta donde el control de dispositivo documentado se adapte a su flujo de trabajo.
Contexto de la solicitud · dispositivoFiltro de página y tiempo
Seleccione una página de resultados basada en cero y, cuando sea necesario, un valor documentado del rango de tiempo.
Contexto de la solicitud · p / dentroParámetros de solicitud
Configura tu solicitud
La guía de solicitudes básicas utiliza el parámetro de consulta que se muestra a continuación. Agregue contexto opcional sólo cuando admita un producto o un requisito de investigación claro.
Pregunta
Pasar el texto de búsqueda en el campo de solicitudes básicas documentado y espacios de código de URL o caracteres especiales.
Región, lengua y dispositivo
Establezca el ID de la región de ubicación de Yandex, el idioma de búsqueda y el perfil documentado de escritorio, móvil o tableta.
Paginación y actualización
Utilice p=0 para la primera página y añada un valor de tiempo soportado como 77 para las últimas 24 horas o 1 para las últimas dos semanas.
Respuesta de carga de utilidad de la fuente
Reciba un sobre JSON, luego aplica su propio contrato de extracción.
Yandex Search API devuelve los metadatos de respuesta y la representación de la página fuente. Diseñar al consumidor alrededor de ese límite antes de agregar almacenamiento, monitoreo o registros de búsqueda derivados.
Respuesta de la API
Envase JSON con la carga útil de HTML SERP fuente.
El envase incluye search_parameters para el contexto de la búsqueda presentada y search_results para la carga útil del HTML SERP de origen.
Inspeccione el estado HTTP antes de leer el cuerpo.
Almacenar sólo el contexto de la solicitud y los datos de origen que necesita su flujo de trabajo.
Trate los cambios en la disposición de la página como un evento de extracción y esquema.
{
"search_parameters": {
"search_engine": "yandex",
"yandex_url": "https://www.yandex.com/search/?text=pizza",
"query": "pizza"
},
"search_results": "<html>...</html>"
}Su solicitud
Extracción y mantenimiento del esquema
Su aplicación posee extracción del HTML devuelto. Su equipo define los campos derivados, reglas de validación, versiones de esquema y respuesta de mantenimiento cuando Yandex actualiza su página.
Una captura contextual
De la solicitud al resultado
- 01Define el contexto de la página
Seleccione la consulta y agregue la región documentada, el idioma, el dispositivo, la página basada en cero y las entradas de rango de tiempo que necesita para su observación.
- 02Envía la solicitud del lado del servidor
Llame al punto final de SERP con una clave de API protegida y el motor fijado en yandex. Establezca un tiempo límite y superfície estados HTTP fallidos.
- 03Validación, extracto y versión
Lea el sobre JSON, preserve su contexto de solicitud y ejecute el HTML fuente a través del proceso de extracción y esquema de su equipo.
La integración
Conecta desde tu servidor
Estos puntos de partida mantienen la clave de API en una variable de entorno, envían la consulta de Solicitudes básicas, utilizan un tiempo de espera del cliente de 120 segundos y hacen explícitos los estados HTTP fallidos.
: "${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- Punto final
/v2- Requerido
api_key+engine=yandex+q- Secreto
WSA_API_KEYpermanece en el lado del servidor- El consumidor
Compruebe el estado, luego lee JSON
Casos de uso
Utilice contextual captura de página de Yandex donde la fuente es el punto de partida correcto.
Visibilidad de búsquedaExplore SERP monitoringPresencia de marcaExplore brand protectionInvestigación de mercadoExplore market researchPrograma de datosReview search data
Observación de Yandex localizada
Captura páginas para combinaciones de consulta controlada, región, idioma, dispositivo y paginado, y luego calcula las métricas definidas por tu equipo.
Revisado por editores regionales
Extraer los dominios y elementos de página relevantes para un proceso de revisión mientras se conserva el contexto de origen de Yandex.
Paisajes de origen y temas
Construir un esquema de extracción definido para los editores, temas o elementos de la página de resultados requeridos por un resumen de investigación.
Registros de búsqueda recurrentes
Definir un esquema explícito, sellos de tiempo, estados de calidad y contrato de entrega cuando las cargas útiles de la fuente de tiempo de solicitud no sean el producto final.
Selección de producto
Compara tus opciones
Motores múltiplesProducto actual Acceso a la página general
API SERP familia
Comparar los contratos de control y respuesta documentados de Google, Bing, DuckDuckGo y Yandex.
Respuestas específicas del motorAPI de búsqueda de Yandex
Envía una consulta de Yandex localizada y recibe el contexto plus la carga útil de HTML SERP fuente en JSON.
API de scraping
Recoger una página web pública elegible cuando su target no esté representado por los controles de búsqueda de Yandex.
Respuesta de la página pública Entrega gestionadaDatos gestionados
Mover conjuntos de consultas, cadencia, esquema, proceso de calidad y entrega en un programa de datos recurrentes acordado.
Contrato de datos operadosEvaluamiento de la producción
Obtén un presupuesto para tu carga de trabajo
Tamaño de contextos, páginas y frecuencia juntos.
Las preguntas
Regiones
Dispositivos
Páginas
Frecuencia
Este es un modelo de evaluación, no una promesa de facturación.
FAQ
Preguntas sobre el producto
¿Qué devuelve la API de búsqueda de Yandex?
Yandex Search API devuelve un envase JSON con metadatos de solicitud y la carga útil de HTML SERP fuente en search_results. No define su esquema de registro en el torrente descendente.
¿Qué valores se requieren para una solicitud de Yandex?
Envía tu clave de API del lado del servidor, configure el motor en yandex y pasa la consulta de búsqueda en q. El texto de la consulta de código URL cuando contiene espacios o caracteres especiales.
¿Cómo escoger la región y el idioma de Yandex?
Utilice lr para el ID de región de Yandex y lang para el idioma de búsqueda. Donde esté documentado, también puede seleccionarse un dominio de Yandex; valide la combinación con búsquedas representativas antes de usarla en producción.
¿Cómo funciona la paginado de Yandex?
Utilice p para la página de resultado. El conteo de páginas comienza en 0, por lo que p=0 solicita la primera página. Mantenga p con el resto del contexto de la solicitud al comparar capturas.
¿Quién mantiene la extracción de la carga útil de Yandex?
Su aplicación posee extracción de la carga útil de HTML SERP fuente, y su equipo posee el esquema derivado y su mantenimiento a medida que cambian los diseños de la página de Yandex.
¿Cómo debería manejar mi aplicación errores de API de Yandex?
Establezca un tiempo de espera explícito del cliente, inspeccione el estado HTTP antes de usar el cuerpo de respuesta, mantenga el contexto de la solicitud suficiente para diagnosticar fallos y aplique retemplajes limitados solo cuando se ajusten a su flujo de trabajo.
Su primera captura de Yandex
Planifica tu recopilación de datos de búsqueda
Comparte el buscador, consultas, mercados y frecuencia. Confirmaremos el formato de respuesta y el precio para tu carga de trabajo.