L'intention régionale reste visible
Gardez l'ID de la région Yandex et la langue à côté de la page capturée afin que les comparaisons ultérieures conservent leur contexte de marché.
API de recherche Yandex pour les SERPs locaux
Capturez le HTML des pages de recherche locales Yandex dans une réponse JSON. Choisissez région, langue, appareil et page, puis appliquez vos règles d’extraction.
Les acheteurs de contrats de capture peuvent évaluer
Capturez la page source et contrôlez l’extraction
La présentation est délibérée
Choisissez le profil de l'appareil documenté et le numéro de page plutôt que de considérer chaque réponse Yandex comme interchangeable.
La limite de réponse est explicite
Planifier une enveloppe JSON contenant la charge utile de l'HTML SERP source au lieu d'assumer un modèle d'enregistrement en aval.
Les décisions de schéma restent à vous
Extraire uniquement les champs dont vous avez besoin dans votre flux de travail, la version de ce schéma et décider comment gérer les modifications de page.
- Moteuryandex
- Je vous demande .pizza
- Régionlr 213
- La langueru
- Appareildesktop
- Pagep 0
- La fenêtredans les limites de 77
Conservez cette empreinte avec la charge utile pour que les équipes puissent comparer des captures similaires et diagnostiquer des changements d'extraction.
Surface de Yandex documentée
Capturez la page de résultats définie par votre contexte régional et de présentation.
Le point d'extrémité de Yandex accepte une requête de recherche plus dans un contexte facultatif. Commencez par des requêtes représentatives pour les pays, langues, appareils, pages et fenêtres horaires que votre application utilisera réellement.
Identification de localisation de Yandex
Utilisez l'identifiant de région attendu par Yandex pour influencer la page de résultats pour l'emplacement prévu.
Context de la demande · lrLangue de recherche
Accrochez la valeur de langue documentée à l'observation et validez-la avec la région et le jeu de requêtes.
Context de demande · langProfil de l'appareil
Demandez une présentation sur ordinateur de bureau, mobile ou tablette où le contrôle de l'appareil documenté correspond à votre flux de travail.
Context de demande · dispositifFiltre de page et de temps
Sélectionnez une page de résultats basée sur zéro et, le cas échéant, une valeur documentée de la plage de temps.
Contextes de la demande · p / dansParamètres de requête
Configurez votre requête
Le guide des demandes de base utilise le paramètre de requête indiqué ci-dessous. Ajoutez un contexte facultatif uniquement lorsqu'il prend en charge un produit ou une exigence de recherche claire.
Question
Passez le texte de recherche dans le champ de requêtes de base documenté et les espaces de code d'URL ou les caractères spéciaux.
Région, langue et appareil
Définir l'ID de la région de localisation de Yandex, la langue de recherche et le profil documenté du bureau, du mobile ou de la tablette.
Paginaison et récente
Utilisez p=0 pour la première page et ajoutez une valeur de temps prise en charge comme 77 pour les 24 dernières heures ou 1 pour les deux dernières semaines.
Réponse de la charge utile de la source
Recevez une enveloppe JSON, puis appliquez votre propre contrat d'extraction.
L'API de recherche Yandex renvoie les métadonnées de réponse et la représentation de la page source.
Réponse à l'API
Enveloppe JSON avec la charge utile HTML SERP source.
L' enveloppe comprend search_parameters pour le contexte de recherche présentée et search_results pour la charge utile du SERP HTML source.
Vérifiez l'état HTTP avant de lire le corps.
Enregistrez uniquement le contexte de la demande et les données de source dont vous avez besoin pour votre flux de travail.
Traitez les modifications de la mise en page comme un événement d'extraction et de schéma.
{
"search_parameters": {
"search_engine": "yandex",
"yandex_url": "https://www.yandex.com/search/?text=pizza",
"query": "pizza"
},
"search_results": "<html>...</html>"
}Votre demande
Extraction et maintenance du schéma
Votre application possède l'extraction du HTML retourné. Votre équipe définit les champs dérivés, les règles de validation, les versions de schéma et la réponse de maintenance lorsque Yandex met à jour sa page.
Une capture contextuelle
De la requête au résultat
- 01Définir le contexte de la page
Choisissez la requête et ajoutez la région, la langue, l'appareil, la page basée sur zéro et les entrées de la plage de temps dont vous avez besoin pour l'observation.
- 02Envoyer la demande du côté serveur
Appeler le point final du SERP avec une clé API protégée et le moteur réglé sur yandex.
- 03Validation, extrait et version
Lisez l'enveloppe JSON, préservez son contexte de demande et exécutez le HTML source à travers le processus d'extraction et de schéma de votre équipe.
L'intégration
Connectez-vous depuis votre serveur
Ces points de départ conservent la clé API dans une variable d'environnement, envoient la requête de requêtes de base, utilisent un délai client de 120 secondes et rendent explicites les états HTTP infructueux.
: "${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- Point final
/v2- Réservé
api_key+engine=yandex+q- Le secret
WSA_API_KEYreste côté serveur- Consommateur
Vérifiez l'état, puis lisez JSON
Cas d'utilisation
Utilisez des captures contextuelles de page Yandex où la source est le bon point de départ.
Visibilité de la rechercheExplore SERP monitoringPrésence de la marqueExplore brand protectionÉtude de marchéExplore market researchProgramme de donnéesReview search data
Observation Yandex localisée
Capturez des pages pour des combinaisons de requête, de région, de langue, d'appareil et de pagination contrôlées, puis calculez les mesures que votre équipe définit.
Révision par les éditeurs régionaux
Extraire les domaines et les éléments de page pertinents pour un processus de révision tout en préservant le contexte Yandex d'origine.
Paysages de source et de thème
Construire un schéma d'extraction défini pour les éditeurs, les sujets ou les éléments de la page de résultats requis par un bref rapport de recherche.
Enregistrements de recherche récurrents
Définir un schéma explicite, des timestamps, des états de qualité et des contrats de livraison lorsque les charges utiles de la source de demande-temps ne sont pas le produit final.
Choix de produit
Comparez vos options
Moteurs multiplesProduit courant Accès à la page générale
Famille de la famille API SERP
Comparer les contrats de contrôle et de réponse documentés de Google, Bing, DuckDuckGo et Yandex.
Réponses spécifiques au moteurAPI de recherche Yandex
Envoyez une requête Yandex localisée et recevez le contexte plus la charge utile de l'HTML SERP source en JSON.
API de scraping
Retrouvez une page Web publique admissible lorsque votre target n'est pas représenté par les commandes de recherche Yandex.
Réponse à la page publique Livraison géréeDonnées gérées
Mettre les ensembles de requêtes, la cadence, le schéma, le processus de qualité et la livraison dans un programme de données récurrentes convenu.
Contrats de données exploitéesÉvaluation de la production
Obtenez un devis adapté à votre charge de travail
Taille des contextes, pages et fréquence ensemble.
Questions
Les régions
Appareils
Pages
Fréquence
C'est un modèle d'évaluation, pas une promesse de facturation.
FAQ
Questions sur le produit
Qu'est-ce que la API de recherche Yandex retourne ?
Yandex Search API renvoie une enveloppe JSON contenant les métadonnées de la requête et le contenu HTML de la SERP source dans search_results. Elle ne définit pas le schéma de vos enregistrements en aval.
Quelles valeurs sont requises pour une demande Yandex ?
Envoyez votre clé API côté serveur, définissez le moteur à yandex et passez la requête de recherche dans q. Le texte de requête de code URL lorsqu'il contient des espaces ou des caractères spéciaux.
Comment choisir la région et la langue de Yandex ?
Utilisez lr pour l’identifiant de région Yandex et lang pour la langue de recherche. Un domaine Yandex peut également être sélectionné lorsque cela est documenté ; validez la combinaison avec des recherches représentatives avant toute mise en production.
Comment fonctionne la pagination Yandex ?
Utilisez p pour la page de résultat. Le comptage de page commence à 0, donc p=0 demande la première page. Gardez p avec le reste du contexte de la demande lors de la comparaison des captures.
Qui maintient l'extraction de la charge utile de Yandex ?
Votre application possède l'extraction de la charge utile de l'HTML SERP source, et votre équipe possède le schéma dérivé et sa maintenance à mesure que les mises en page de Yandex changent.
Comment mon application doit-elle gérer les erreurs de l'API Yandex ?
Définir un délai explicite du client, inspecter l'état HTTP avant d'utiliser le corps de réponse, conserver suffisamment de contexte de demande pour diagnostiquer les défaillances et appliquer des tentatives limitées uniquement lorsqu'elles correspondent à votre flux de travail.
Votre première capture de Yandex
Planifiez votre collecte de données de recherche
Partagez moteur, requêtes, marchés et fréquence. Nous confirmons le format de réponse et le prix pour votre charge de travail.