Beschränken Sie die Beobachtung
Bewahren Sie die Abfrage, den Ort, die Schnittstellensprache, den Sicherheitsbesuch, die Zeiträume und das Gerät neben jeder Aufnahme.
DuckDuckGo Search API für SERP Capture
Erfassen Sie DuckDuckGo-Suchergebnisseiten als HTML in einer JSON-Antwort. Wählen Sie Suchbegriff und Filter und extrahieren Sie die Felder für Ihre Anwendung.
Eine klare Übergabe
Quellseite erfassen und Extraktion steuern
Behalte die Quelle
Erhalten Sie die Quelle SERP HTML-Nutzkosten in einem JSON-Umschlag, anstatt ein festes Abwärtsschema anzunehmen.
Gestalten Sie Ihren Abzug
Wählen Sie nur die Felder aus, die Ihr Workflow benötigt, und validieren Sie diese mit repräsentativen Nutzlasten.
Version Layout Änderungen
Behandeln Sie die Extraktionsregeln und die Aufzeichnungen als Anwendungscode, den Ihr Team testet und pflegt.
WebScrapingAPIDokumentierte Anforderungsausführung
AntwortgrenzeMetadaten + Quelle SERP HTML
Ihre BewerbungExtraktion + Schemapflege
DuckDuckGo Websuche
Ein fokussierter Endpunkt für kontrollierte Source-SERP-Beobachtungen.
Verwenden Sie die DuckDuckGo-Engine für Websuchanfragen mit der dokumentierten Filterfamilie. Validieren Sie tatsächliche Nutzlasten für die Abfragenkombinationen, von denen Ihr Produkt abhängt.
Erfassungsbereich
Abfragekontext eingeben, Quellseiten-Nutzlast aus.
Der Umschlag speichert die eingereichten Suchdaten neben der DuckDuckGo-Ergebnislast, damit Ihre Pipeline die benötigte Herkunft behalten kann.
Locale
Land und Sprache
Geben Sie den Bereich der Suche mit einem dokumentierten kombinierten Gebietsschemawert an.
Präsentation
Sprache der Benutzeroberfläche
Legen Sie die Sprache fest, die von DuckDuckGo-Steuerelementen und -Beschriftungen verwendet wird.
Politik
Sichere Suche
Wählen Sie eine dokumentierte Safe-Search-Stufe für die Anfrage.
Recency
Zeitbereich
Bitte um ein dokumentiertes Fenster für Tag, Woche, Monat oder Jahr oder lassen Sie den Filter aus.
Präsentation
Gerät
Wählen Sie einen dokumentierten Gerätekontext für die angeforderte Ergebnisseite aus.
Dokumentierter Filtersatz
Ihre Anfrage konfigurieren
Beginnen Sie mit der erforderlichen Abfrage. Fügen Sie nur die optionalen DuckDuckGo-Filter hinzu, die der Beobachtung gehören, die Sie reproduzieren möchten.
qErforderlichSuchanfrage
Geben Sie die Bedingungen an, mit denen DuckDuckGo Räume oder Sonderzeichen suchen und URL-Code machen sollte.
klOptionalLand + Sprache
Verwenden Sie einen dokumentierten kombinierten Lokalcode, z. B. en_US, wenn die Anfrage diesen Kontext benötigt.
kadOptionalSprache der Benutzeroberfläche
Wählen Sie die dokumentierte Sprache für DuckDuckGo-Steuerelemente und -Beschriftungen.
kpOptionalSafe-Search-Level
Ein-, moderat oder aus mit dem dokumentierten numerischen Wert.
dfOptionalZeitbereich
Begrenzen Sie die Ergebnisse auf den vergangenen Tag, Woche, Monat oder Jahr oder lassen Sie den Filter für jede Zeit aus.
deviceOptionalGerätekontext
Wählen Sie einen dokumentierten Geräteswert aus, wenn der angeforderte Präsentationskontext wichtig ist.
Source-Payload-Response
Behandeln Sie den JSON-Umschlag als Transportgrenzenicht als Ihr letztes Datensatzmodell.
Die Endpunkt-Antwort ist ein JSON-Einzelkopf mit Anfrage-Metadaten und der Quelle SERP HTML-Nutzkosten. Ihre Anwendung besitzt Extraktion, Validierung und Schema-Wartung.
Dokumentierte Form
JSONMetadaten neben der Payload
{
"search_parameters": {
"search_engine": "duckduckgo",
"query": "privacy research"
},
"search_results": "<html>...source SERP HTML...</html>"
}Die Präsenz des Feldes und die Kennzeichnung der Quelle können sich ändern. Speichern und überprüfen Sie nur, was Ihr Workflow benötigt.
Von der Anfrage zum gepflegten Datensatz
Von der Anfrage zum Ergebnis
- 01Kontext definieren
Wählen Sie die Abfrage und nur die dokumentierten Filter aus, die für die Beobachtung erforderlich sind.
- 02Senden und validieren
Rufen Sie an die Serverseite, überprüfen Sie den HTTP-Status und bestätigen Sie den erwarteten Quell-Nutzkosten.
- 03Auszug und Version
Verwenden Sie Ihre getesteten Regeln, validieren Sie die erforderlichen Felder und fügen Sie Ihre Schemaversion ein.
Integration
Von Ihrem Server verbinden
Behalten Sie die Anmeldeinformationen auf der Serverseite, URL-Code-Anforderungswerte, setzen Sie eine begrenzte Zeit, überprüfen Sie die nicht erfolgreichen HTTP-Status und validieren Sie den Umschlag vor der Extraction.
: "${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=duckduckgo" \
--data-urlencode "q=privacy research" \
--data-urlencode "kl=en_US" \
--data-urlencode "kad=en_US" \
--data-urlencode "kp=1" \
--data-urlencode "df=w" \
--data-urlencode "device=desktop"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": "duckduckgo",
"q": "privacy research",
kl: "en_US",
kad: "en_US",
kp: "1",
df: "w",
device: "desktop",
});
const response = await fetch(
"https://serpapi.webscrapingapi.com/v2?" + parameters,
{ 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")
response = requests.get(
"https://serpapi.webscrapingapi.com/v2",
params={
"api_key": api_key,
"engine": "duckduckgo",
"q": "privacy research",
"kl": "en_US",
"kad": "en_US",
"kp": "1",
"df": "w",
"device": "desktop",
},
timeout=120,
)
response.raise_for_status()
print(response.json())<?php
$apiKey = getenv("WSA_API_KEY");
if ($apiKey === false || $apiKey === "") {
throw new RuntimeException("WSA_API_KEY is required");
}
$endpoint = "https://serpapi.webscrapingapi.com/v2?engine=duckduckgo&q=privacy%20research";
$parameters = http_build_query([
"api_key" => $apiKey,
"kl" => "en_US",
"kad" => "en_US",
"kp" => "1",
"df" => "w",
"device" => "desktop",
]);
$client = curl_init($endpoint . "&" . $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 >= 400) {
throw new RuntimeException("API status " . $status);
}
echo $body;package main
import (
"fmt"
"io"
"net/http"
"net/url"
"os"
"time"
)
func main() {
apiKey := os.Getenv("WSA_API_KEY")
if apiKey == "" { panic("WSA_API_KEY is required") }
endpoint, err := url.Parse(
"https://serpapi.webscrapingapi.com/v2?engine=duckduckgo&q=privacy%20research",
)
if err != nil { panic(err) }
query := endpoint.Query()
query.Set("api_key", apiKey)
query.Set("kl", "en_US")
query.Set("kad", "en_US")
query.Set("kp", "1")
query.Set("df", "w")
query.Set("device", "desktop")
endpoint.RawQuery = query.Encode()
client := &http.Client{Timeout: 120 * time.Second}
response, err := client.Get(endpoint.String())
if err != nil { panic(err) }
defer response.Body.Close()
if response.StatusCode >= 400 {
panic(fmt.Sprintf("API status %d", response.StatusCode))
}
body, err := io.ReadAll(response.Body)
if err != nil { panic(err) }
fmt.Println(string(body))
}import java.net.URI;
import java.net.URLEncoder;
import java.net.http.*;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
public final class DuckDuckGoExample {
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 key = URLEncoder.encode(apiKey, StandardCharsets.UTF_8);
String url = "https://serpapi.webscrapingapi.com/v2" +
"?api_key=" + key + "&engine=duckduckgo" +
"&q=privacy%20research&kl=en_US&kad=en_US" +
"&kp=1&df=w&device=desktop";
var request = HttpRequest.newBuilder(URI.create(url))
.timeout(Duration.ofSeconds(120)).GET().build();
var response = HttpClient.newHttpClient()
.send(request, HttpResponse.BodyHandlers.ofString());
if (response.statusCode() >= 400) {
throw new RuntimeException("API status " + response.statusCode());
}
System.out.println(response.body());
}
}using System;
using System.Net;
using System.Net.Http;
var rawApiKey = Environment.GetEnvironmentVariable("WSA_API_KEY");
if (string.IsNullOrWhiteSpace(rawApiKey)) {
throw new InvalidOperationException("WSA_API_KEY is required");
}
var key = WebUtility.UrlEncode(rawApiKey);
var url = "https://serpapi.webscrapingapi.com/v2" +
"?api_key=" + key + "&engine=duckduckgo" +
"&q=privacy%20research&kl=en_US&kad=en_US" +
"&kp=1&df=w&device=desktop";
using var client = new HttpClient {
Timeout = TimeSpan.FromSeconds(120)
};
var response = await client.GetAsync(url);
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?
uri = URI("https://serpapi.webscrapingapi.com/v2?engine=duckduckgo&q=privacy%20research")
parameters = URI.decode_www_form(uri.query)
parameters << ["api_key", api_key]
parameters << ["kl", "en_US"]
parameters << ["kad", "en_US"]
parameters << ["kp", "1"]
parameters << ["df", "w"]
parameters << ["device", "desktop"]
uri.query = URI.encode_www_form(parameters)
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}"
end
puts response.body- Secret
WSA_API_KEYbleibt serverseitig- Motor
engine=duckduckgo- Beispiel für Filter
kl=en_US- Verbraucher
Status, Umschlag und Quelle prüfen
Source-first-Anwendungsfälle
Verwenden Sie kontrollierte Aufnahmen, wenn Ihr Team einen eigenen Extraktionsvertrag braucht.
Suche nach BeobachtungExplore SERP monitoringMarktforschung und AnalyseExplore market researchMarkensichtbarkeitExplore brand protectionDatenvertragReview search data
Kontrollierte Sichtbarkeitsforschung
Erfassen Sie vergleichbare Quellseiten von DuckDuckGo und ermitteln Sie dann die Felder und Qualitätszustände, die Ihr Überwachungsmodell benötigt.
Quellen- und Themenübersicht
Behalten Sie die Quellnachweise für Abfragegruppen und wenden Sie Ihre eigenen Einstufungs-, Überprüfungs- und Schema-Regeln an.
Domain- und Erwähnungs-Checks
Entnehmen Sie genehmigte Signale aus kontrollierten Nutzlasten, während Sie die Interpretation und die Eskalation mit Ihrer Anwendung behalten.
Versionierte SERP-Datensätze
Definition des Schemas, der Herkunft, der Validierungszustände und der nach der Erfassung der Anfragezeit erforderlichen Aufbewahrungsrichtlinien.
Die Produktauswahl
Ihre Optionen vergleichen
NetzwerkzugriffAktuelles Produkt Managed Delivery
Proxy-Infrastruktur
Ihr Team baut den Such-Client, die Logik des Abrufs, das Extraktions- und Reaktionsmodell auf.
Die meisten Anwendungen SeitenauswahlScraper-API
Senden Sie eine berechtigte URL der öffentlichen Seite und besitzen Sie die komplette Extraktions- und Schema-Schicht.
Allgemeiner WebzugriffDuckDuckGo-Such-API
Senden Sie dokumentierte Suchkontext und erhalten Sie Metadaten plus Quelle SERP HTML in einem JSON-Abschlag.
Verwaltete Daten
Umfang eines vereinbarten Abfragen-Sets, der Kadenz, des Schemas, des Qualitätsprozesses und der Bereitstellung mit WebScrapingAPI.
Vereinbartes BetriebsmodellAuswertung der Produktion
Ein Angebot für Ihre Aufgaben erhalten
Zählen Sie Kontexte und Wartungsarbeiten zusammen.
Abfragen
Filtersätze für Filter
Lauffrequenz
Extraktortest
Dies ist ein Bewertungsmodell, keine Abrechnungsformel. Berücksichtigen Sie in Ihrem Produktivdesign die Aufbewahrung der Quellen, die Schemavalidierung und den Umgang mit Layout-Änderungen.
FAQ
Fragen zum Produkt
Was gibt die DuckDuckGo-Such-API zurück?
Der Endpunkt gibt einen JSON-Abschlag zurück, der die Anfrage-Metadaten und die Quelle SERP HTML-Nutzkosten enthält. Es definiert nicht Ihr Abwärts-Date-Schema; Ihre Anwendung besitzt die Extraktion und die Schema-Wartung.
Wem gehört die Extraktion, wenn sich das Layout von DuckDuckGo ändert?
Ihr Team besitzt Extraktionsregeln, Validierung und Schema-Wartung für die Quelle SERP HTML-Nutzkosten. Wenn DuckDuckGo seine Seite ändert, testen Sie Ihren Extraktor gegen repräsentative Antworten, bevor Sie Änderungen vorantreiben.
Welche DuckDuckGo-Filter kann ich steuern?
Die auf dieser Seite verwendeten dokumentierten Kontrollen sind q für die Abfrage, kl für Land und Sprache, kad für Schnittstellensprache, kp für sichere Suche und df für einen Zeitbereich.
Ist die Quell-Payload bereits auf mein Schema abgestimmt?
Nein. Die Antwort bewahrt die Quelle SERP HTML-Nutzkosten in einem JSON-Abschlag. Ihre Anwendung entscheidet, welche Felder extrahiert werden, wie sie modelliert werden und wie das resultierende Schema versionert wird.
Wie soll meine Anwendung mit erfolglosen Anfragen umgehen?
Überprüfen Sie den HTTP-Status, bevor Sie den Körper lesen, speichern Sie ausreichend Anforderungskontext, um Fehler zu untersuchen, und verwenden Sie ein begrenztes Wiederversuchverhalten, das Ihrem Workflow entspricht.
Wann sollte ich stattdessen Verwaltete Daten in Betracht ziehen?
Wählen Sie die API, wenn Ihr Team die Aufnahme der Anfragezeit wünscht und Extraktion, Schema, Speicherung und Planung betreiben wird. Verwaltete Daten Wenn Sie eine vereinbarte Abfrage, die Kadenz, das Schema, den Qualitätsprozess und die Bereitstellung mit WebScrapingAPI.
Ihre erste Quellenerfassung
Ihre Suchdatenerfassung planen
Teilen Sie Suchmaschine, Suchbegriffe, Märkte und Aktualisierungsplan. Wir bestätigen Antwortformat und Preise für Ihre Aufgaben.