Regionale Absicht bleibt sichtbar
Bewahren Sie die Yandex-Region-ID und die Sprache neben der erfassten Seite, damit spätere Vergleiche ihren Marktkontext behalten.
Yandex Search API für lokale SERPs
Erfassen Sie lokalisierte Yandex-Suchergebnisseiten als HTML in einer JSON-Antwort. Wählen Sie Region, Sprache, Gerät und Seite und wenden Sie eigene Extraktionsregeln an.
Einen Erfassungsvertrag können Käufer bewerten
Quellseite erfassen und Extraktion steuern
Die Darstellung ist bewusst
Wählen Sie das dokumentierte Gerätsprofil und die Seitennummer anstatt jede Yandex-Antwort als austauschbar zu behandeln.
Die Antwortgrenze ist explizit
Planen Sie einen JSON-Abschluss mit der Quelle SERP HTML-Nutzkosten anstelle eines nachgelagerten Datensatzmodells.
Schema-Entscheidungen bleiben bei Ihnen
Entnehmen Sie nur die Felder, die Ihr Workflow benötigt, version dieses Schemas und entscheiden Sie, wie die Änderungen der Seiten behandelt werden sollen.
- Engineyandex
- Querypizza
- Regionlr 213
- Spracheru
- Gerätdesktop
- Pagep 0
- Fensterinnerhalb von 77
Speichern Sie diesen Fingerabdruck mit der Nutzlast, damit die Teams ähnliche Aufnahmen vergleichen und Änderungen bei der Extraktion diagnostizieren können.
Dokumentierte Yandex-Oberfläche
Erfassen Sie die Ergebnisseite, die nach Ihrem regionalen und präsentierenden Kontext definiert ist.
Der Yandex Endpunkt akzeptiert eine Suchfrage plus optionalen Kontext. Beginnen Sie mit repräsentativen Anfragen für die Länder, Sprachen, Geräte, Seiten und Zeitfenster, die Ihre Anwendung tatsächlich verwenden wird.
Yandex-Standort-ID
Verwenden Sie den von Yandex erwarteten Region-Identifikator, um die Ergebnisseite für den beabsichtigten Standort zu beeinflussen.
Anfragekontext · lrSprache der Suche
Fügen Sie den dokumentierten Sprachwert zur Beobachtung an und validieren Sie ihn mit der Region und dem Abfrage-Set.
Anfragekontext · langGeräteprofil
Bitte eine Präsentation für Desktop, Mobiltelefon oder Tablet, in der die dokumentierte Gerätekontrolle Ihrem Arbeitsfluss entspricht.
Anforderungskontext · GerätSeiten- und Zeitfilter
Wählen Sie eine nullbasierte Ergebnisseite und, falls erforderlich, einen dokumentierten Zeitbereichswert aus.
Anfragekontext · p / withinAnfrageparameter
Ihre Anfrage konfigurieren
Der Leitfaden für Grundanfragen verwendet den nachstehend gezeigten Abfragenparameter.
Übergeben Sie den Suchtext im dokumentierten Feld Grundanfragen und den URL-Code-Frächen oder Sonderzeichen.
Region, Sprache und Gerät
Stellen Sie die Yandex-Lokationsregion-ID, die Suchsprache und das dokumentierte Desktop-, Mobil- oder Tablet-Profil ein.
Paginierung und Aktualität
Verwenden Sie p=0 für die erste Seite und fügen Sie einen unterstützten Zeitwert hinzu wie 77 für die letzten 24 Stunden oder 1 für die letzten zwei Wochen.
Source-Payload-Response
Erhalten Sie einen JSON-Hüllkurven und wenden Sie dann Ihren eigenen Extraktionsvertrag an.
Die Yandex Search API gibt die Reaktionsmetadaten und die Quellseitenrepräsentation zurück. Entwerfen Sie den Verbraucher um diese Grenze, bevor Sie Speicher-, Überwachungs- oder abgeleitete Suchdateien hinzufügen.
API-Antwort
JSON-Hüllkurve mit der Quell-SERP-HTML-Nutzlast.
Der Umschlag enthält : search_parameters für den eingereichten Suchkontext und search_results Für die Quell-SERP-HTML-Nutzlast.
Überprüfen Sie den HTTP-Status, bevor Sie den Textkörper lesen.
Speichern Sie nur den Anforderungskontext und die Daten, die Ihr Workflow benötigt.
Seitenlayoutänderungen als Extraktions- und Schema-Ereignis behandeln.
{
"search_parameters": {
"search_engine": "yandex",
"yandex_url": "https://www.yandex.com/search/?text=pizza",
"query": "pizza"
},
"search_results": "<html>...</html>"
}Ihre Bewerbungsunterlagen
Extraktion und Schemapflege
Ihre Anwendung besitzt die Extraktion aus dem zurückgegebenen HTML. Ihr Team definiert die abgeleiteten Felder, Validierungsregeln, Schema-Versionen und Wartungsreaktion, wenn Yandex seine Seite aktualisiert.
Eine kontextbezogene Aufnahme
Von der Anfrage zum Ergebnis
- 01Definieren Sie den Seitenkontext
Wählen Sie die Abfrage aus und fügen Sie die dokumentierte Region, Sprache, Gerät, nullbasierte Seite und Zeitreihen-Eingaben hinzu, die Sie für Ihre Beobachtung benötigen.
- 02Senden der serverseitigen Anforderung
Rufen Sie den SERP-Endpunkt mit einem geschützten API-Schlüssel und einer Engine auf Yandex. Setzen Sie eine Zeitfrist und stellen Sie erfolglose HTTP-Status auf.
- 03Validieren, Extrahieren und Versionieren
Lesen Sie den JSON-Abschlag, speichern Sie den Anfrage-Kontext und führen Sie die Quelle HTML durch den Extraktions- und Schema-Prozess Ihres Teams aus.
Integration
Von Ihrem Server verbinden
Diese Ausgangspunktstellen halten den API-Schlüssel in einer Umgebungsvariable, senden die Basisanfrage, verwenden einen 120 Sekunden-Client-Timeout und machen die nicht erfolgreichen HTTP-Ständungen explizit.
: "${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- Endpunkt
/v2- Erforderlich
api_key+engine=yandex+q- Secret
WSA_API_KEYbleibt serverseitig- Verbraucher
Status prüfen, dann JSON lesen
Use Cases für
Verwenden Sie kontextuelle Yandex-Seiten, die festlegen, wo die Quelle der richtige Ausgangspunkt ist.
Sichtbarkeit der SucheExplore SERP monitoringMarkenpräsenzExplore brand protectionMarktforschung und AnalyseExplore market researchDatenprogrammReview search data
Lokalisierte Yandex-Beobachtung
Fangen Sie Seiten für kontrollierte Abfragen, Regionen, Sprachen, Geräte und Paginierungskombinationen und berechnen Sie dann die von Ihrem Team definierten Metriken.
Regionale Verlagsbewertung
Die für einen Überprüfungsvorgang relevanten Domains und Seitenelemente extrahieren und den ursprünglichen Yandex-Kontext erhalten.
Quellen- und Themenlandschaften
Erstellen Sie ein definiertes Extraktionsschema für die Verlage, Themen oder Ergebnisseitelemente, die von einer Forschungsbriefung benötigt werden.
Wiederkehrende Suchdatensätze
Definition eines expliziten Schemas, Zeitstempels, Qualitätszustand und Liefervertrag, wenn die Nutzlasten der Anforderungszeitquelle nicht das Endprodukt sind.
Die Produktauswahl
Ihre Optionen vergleichen
Mehrere MotorenAktuelles Produkt Allgemeiner Seitenzugriff
SERP-API
Vergleichen Sie die dokumentierten Google, Bing, DuckDuckGo und Yandex-Kontroll- und Reaktionsverträge.
Motorspezifische AnsprechverhaltenYandex-Such-API
Senden Sie eine lokalisierte Yandex-Abfrage und erhalten Sie den Kontext plus der Quelle SERP HTML-Nutzkosten in JSON.
Scraper-API
Erhalten Sie eine zugelassenen öffentlichen Webseite, wenn Ihre target nicht durch die Yandex-Suchanzeige-Kontrollen dargestellt wird.
Antwort auf öffentliche Seite Managed DeliveryVerwaltete Daten
Bewegen Sie Abfragen, Kadenz, Schema, Qualitätsprozess und Lieferung in ein vereinbartes wiederkehrendes Datenprogramm.
BetriebsdatenvertragAuswertung der Produktion
Ein Angebot für Ihre Aufgaben erhalten
Größen Sie Kontexte, Seiten und Häufigkeit zusammen.
Abfragen
Regionen
Geräte
Seiten
Frequenz
Dies ist ein Bewertungsmodell, keine Abrechnungszusage. Maßgeblich sind die aktuellen Preise und Tarifdetails als kommerzielle Referenz.
FAQ
Fragen zum Produkt
Was gibt die Yandex Search API zurück?
Yandex Search API gibt einen JSON-Umschlag mit Anfrage-Metadaten und der Quelle SERP HTML-Nutzkost in search_results zurück. Es definiert nicht Ihr Nachströmschema.
Welche Werte sind für eine Yandex-Anfrage erforderlich?
Schicken Sie Ihren Server-API-Schlüssel, setzen Sie die Engine auf Yandex und geben Sie die Suchfrage in q. URL-kodierte Abfragetext, wenn sie Räume oder spezielle Zeichen enthält.
Wie wähle ich die Yandex-Region und -Sprache aus?
Verwenden Sie lr für die Yandex-Regions-ID und lang für die Suchsprache. Wo dokumentiert, lässt sich auch eine Yandex-Domain auswählen; validieren Sie die Kombination mit repräsentativen Suchanfragen, bevor Sie sie produktiv einsetzen.
Wie funktioniert Yandex Paginierung?
Verwenden Sie p für die Ergebnisseite. Die Seitezählung beginnt bei 0, so dass p=0 die erste Seite anfordert. Halten Sie p mit dem Rest des Anfrage-Kontextes zusammen, wenn Sie Abnahmen vergleichen.
Wer pflegt die Extraktion aus der Yandex-Nutzlast?
Ihre Anwendung besitzt die Extraktion aus der Quelle SERP HTML Nutzlast, und Ihr Team besitzt das abgeleitete Schema und seine Wartung, wenn sich die Layouts der Yandex-Seiten ändern.
Wie soll meine Anwendung mit Yandex API-Fehlern umgehen?
Setzen Sie eine explizite Client-Timeout, überprüfen Sie den HTTP-Status vor der Verwendung des Reaktionskörpers, speichern Sie genügend Anforderungskontext, um Fehler zu diagnostizieren, und wenden Sie begrenzte Wiederversuche nur an, wenn sie Ihrem Workflow passen.
Deine erste Yandex-Aufnahme
Ihre Suchdatenerfassung planen
Teilen Sie Suchmaschine, Suchbegriffe, Märkte und Aktualisierungsplan. Wir bestätigen Antwortformat und Preise für Ihre Aufgaben.