Yandex-Such-API
Yandex Search API für lokalisierte SERP-Erfassung.
Erfassen Sie die für eine bestimmte Region, Sprache, Gerät, Seite und Zeitfenster erstellte Yandex-Ergebnisseite. Die API gibt die Anfrage-Metadaten und die Quelle SERP HTML-Nutzkosten in einem JSON-Umschlag zurück, den Ihre Anwendung verarbeiten kann.
Serverseitige GET-API · Beginnen mitapi_key + engine=yandex + q · Mit einem Datenexperten sprechen
- Regionaler KontextYandex-Standortregion-ID
- SeitensteuerelementeSprache, Gerät und Seite
- ZeitfilterDokumentiert innerhalb von Werten
- QuellenantwortHTML-Nutzdaten in JSON
Web data workflow · yandex searchReady
query pizza
region Moscow
lang ru
fielddevice desktop
stackDie Seite explizit halten
stackJSON-Hüllkurve
figurerequest context
figurelr 213
{
"search_parameters": {
"search_engine": "yandex",
"query": "pizza"
},
"search_results":
"<html>...</html>"
}Einen Erfassungsvertrag können Käufer bewerten
Kennen Sie den Kontext der Seite, die Nutzlast und die Eigentumsgrenze, bevor Sie integrieren.
Die Yandex-Suche-API gibt den Produkt- und Datenteams eine dokumentierte Anforderungsschicht für die lokalisierte Seiteaufnahme. Ihr Team behält die Kontrolle über das Extraktionsmodell und über die Art und Weise, wie jede Beobachtung in den Workflows nachgelagert wird.
01
Regionale Absicht bleibt sichtbar
Bewahren Sie die Yandex-Region-ID und die Sprache neben der erfassten Seite, damit spätere Vergleiche ihren Marktkontext behalten.
02
Die Darstellung ist bewusst
Wählen Sie das dokumentierte Gerätsprofil und die Seitennummer anstatt jede Yandex-Antwort als austauschbar zu behandeln.
03
Die Antwortgrenze ist explizit
Planen Sie einen JSON-Abschluss mit der Quelle SERP HTML-Nutzkosten anstelle eines nachgelagerten Datensatzmodells.
04
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.
- 01
Engineyandex
- 02
Querypizza
- 03
Regionlr 213
- 04
Spracheru
- 05
Gerätdesktop
- 06
Pagep 0
- 07
Fensterinnerhalb von 77
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.
Region
Yandex-Standort-ID
Verwenden Sie den von Yandex erwarteten Region-Identifikator, um die Ergebnisseite für den beabsichtigten Standort zu beeinflussen.
Anfragekontext · lr
Sprache
Sprache der Suche
Fügen Sie den dokumentierten Sprachwert zur Beobachtung an und validieren Sie ihn mit der Region und dem Abfrage-Set.
Anfragekontext · lang
Präsentation
Geräteprofil
Bitte eine Präsentation für Desktop, Mobiltelefon oder Tablet, in der die dokumentierte Gerätekontrolle Ihrem Arbeitsfluss entspricht.
Anforderungskontext · Gerät
Seitenfenster
Seiten- und Zeitfilter
Wählen Sie eine nullbasierte Ergebnisseite und, falls erforderlich, einen dokumentierten Zeitbereichswert aus.
Anfragekontext · p / within
Domain-Kontext
Überprüfen Sie die Domain, die Region und die Sprache zusammen.
Die Parameterreferenz dokumentiert auch die optionelle Yandex-Domainselektion.
Anforderung von Steuerelementen
Definieren Sie die Yandex-Seite, die Ihre Anwendung beobachten soll.
Der Leitfaden für Grundanfragen verwendet den nachstehend gezeigten Abfragenparameter.
Suchabsicht
Übergeben Sie den Suchtext im dokumentierten Feld Grundanfragen und den URL-Code-Frächen oder Sonderzeichen.
q
Lokalisierung und Präsentation
Region, Sprache und Gerät
Stellen Sie die Yandex-Lokationsregion-ID, die Suchsprache und das dokumentierte Desktop-, Mobil- oder Tablet-Profil ein.
lr lang device
Seitenfenster
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.
p within
Anmerkung zur Umsetzung: use api_key, engine=yandex, undqDie Seitenummer ist nullbasiert; sie beschreibt, welche Seite angefordert wurde, nicht eine universelle Rangfolge in verschiedenen Kontexten.
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_parametersfür den eingereichten Suchkontext undsearch_resultsFü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.
application/json source payload{ "search_parameters": { "search_engine": "yandex", "yandex_url": "https://www.yandex.com/search/?text=pizza", "query": "pizza" }, "search_results": "<html>...</html>" }Your application
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.
Antwortgrenze
Der Endpunkt liefert den Seitenkontext und die Quell-HTML innerhalb von JSON. Es definiert nicht die Kunden-gegebenen Aufzeichnungen, Rankings, Warnungen oder Geschäftsinterpretationen, die Ihr System ableiten kann.
Eine kontextbezogene Aufnahme
From a Yandex query to an owned extraction pipeline in three steps.
Ihre Anwendung definiert die Seite und verbraucht die Quelllast. WebScrapingAPI bedient den unterstützten Anforderungsweg zwischen diesen beiden Verantwortlichkeiten.
- 01
Definieren 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.
- 02
Senden 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.
- 03
Validieren, 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
Führen Sie eine sichere Yandex-Anfrage aus Ihrem serverseitigen Stack aus.
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.
Anfrage brief anfordern
Beginnen Sie mit der dokumentierten Pizza-Abfrage.
Bestätigen Sie zuerst die Quelle-Antwort. Fügen Sie dann die von Ihrem Produkt erforderlichen Regional-, Sprache-, Gerät-, Seiten- und Zeitsteuerungen hinzu.
- Endpunkt
/v2- Erforderlich
api_key+engine=yandex+q- Secret
WSA_API_KEYbleibt serverseitig- Verbraucher
- Status prüfen, dann JSON lesen
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());: "${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"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());
}
}
}// 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());<?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;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())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.bodyUse Cases für
Verwenden Sie kontextuelle Yandex-Seiten, die festlegen, wo die Quelle der richtige Ausgangspunkt ist.
Jeder Arbeitsfluss sollte seinen Fingerabdruck auf dem Antrag aufbewahren und festlegen, wie Änderungen der Quellseiten die Gewinnung, den Vergleich, die Überprüfung und die Abwicklung von Entscheidungen beeinflussen.
Sichtbarkeit der Suche
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.
SERP-Monitoring erkunden →
Markenpräsenz
Regionale Verlagsbewertung
Die für einen Überprüfungsvorgang relevanten Domains und Seitenelemente extrahieren und den ursprünglichen Yandex-Kontext erhalten.
Markenschutz erkunden →
Marktforschung und Analyse
Quellen- und Themenlandschaften
Erstellen Sie ein definiertes Extraktionsschema für die Verlage, Themen oder Ergebnisseitelemente, die von einer Forschungsbriefung benötigt werden.
Marktforschung entdecken →
Datenprogramm
Wiederkehrende Suchdatensätze
Definition eines expliziten Schemas, Zeitstempels, Qualitätszustand und Liefervertrag, wenn die Nutzlasten der Anforderungszeitquelle nicht das Endprodukt sind.
Suchdaten überprüfen →
Die Produktauswahl
Wählen Sie nach der Reaktionsfähigkeit und dem Betriebseigentum, die Ihr Team benötigt.
Yandex Search API ist die fokussierte Option, wenn die Quelle Yandex Ergebnisseite und der Anfrage-Kontext Ihrer Anwendung passen. Erweitern oder verändern Sie Eigentum, wenn sich Ihre Anforderungen ändern.
Multiple engines
SERP-API
Vergleichen Sie die dokumentierten Google, Bing, DuckDuckGo und Yandex-Kontroll- und Reaktionsverträge.
Motorspezifische Ansprechverhalten
Current product
Yandex-Such-API
Senden Sie eine lokalisierte Yandex-Abfrage und erhalten Sie den Kontext plus der Quelle SERP HTML-Nutzkosten in JSON.
Yandex-Quellseitenerfassung
General page access
Scraper-API
Erhalten Sie eine zugelassenen öffentlichen Webseite, wenn Ihre target nicht durch die Yandex-Suchanzeige-Kontrollen dargestellt wird.
Antwort auf öffentliche Seite
Managed delivery
Verwaltete Daten
Bewegen Sie Abfragen, Kadenz, Schema, Qualitätsprozess und Lieferung in ein vereinbartes wiederkehrendes Datenprogramm.
Betriebsdatenvertrag
Auswertung der Produktion
Testen Sie die regionale Seitenmatrix, von der Ihre Anwendung abhängt.
Verwenden Sie repräsentative Aufnahmen, bevor Sie einen Plan auswählen.
Schätzung der Anforderungsmatrix
Größen Sie Kontexte, Seiten und Häufigkeit zusammen.
Anschauliche Formel für das Yandex-Anfragevolumen
Abfragen × Regionen × Geräte × Seiten × Frequenz
Das ist ein Bewertungsmodell, kein Abrechnungsversprechen.
Checkliste zur Bewertung
- Kontext
Regionen, Sprachen und Domains
- Präsentation
Geräte und Zero-based-Seiten
- Nutzlast
Quell-HTML-Variationen
- Verbraucher
Extraktion und Schemaversionen
- Operations
Timeouts, Fehler, Wiederholungen, Speicher
FAQ
Yandex Search API Fragen für eine fundierte Bewertung.
Verwenden Sie diese Antworten zur Produktwahl, behandeln Sie dann die aktuelle Yandex-Endpunktdokumentation und repräsentative Anfragen als die Implementierungsquelle der Wahrheit.
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-Location-Region-ID und lang für die Suchsprache.
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
Testen Sie eine regionale Seite und ihren Quell-Payload-Verbraucher.
Beginnen Sie mit der dokumentierten Pizzaanfrage, und fügen Sie dann die Kontexte hinzu, die Ihr Produkt tatsächlich beobachten wird.