Limiter l'observation
Gardez la requête, la localisation, le langage d'interface, le niveau de recherche sécurisée, la plage de temps et l'appareil à côté de chaque capture.
API de recherche DuckDuckGo pour la capture de SERP
Capturez le HTML des pages de recherche DuckDuckGo dans une réponse JSON. Définissez la requête et les filtres, puis extrayez les champs utiles à votre application.
Une transmission claire
Capturez la page source et contrôlez l’extraction
Restez à la source
Recevez la charge utile du SERP HTML source dans une enveloppe JSON plutôt que d'assumer un schéma en aval fixe.
Conceptez votre extracteur
Sélectionnez uniquement les champs dont votre flux de travail a besoin et validez-les par rapport aux charges utiles représentatives.
Modification de la mise en page de la version
Traitez les règles d'extraction et les schémas d'enregistrement comme des codes d'application que votre équipe teste et maintient.
WebScrapingAPIExécution de la demande documentée
Limite de réponseMetadata + source de SERP HTML
Votre demandeExtraction + entretien du schéma
Recherche en ligne du DuckDuckGo
Un point final ciblé pour les observations contrôlées de la source-SERP.
Utilisez le moteur DuckDuckGo pour les requêtes de recherche Web avec la famille de filtres documentés. Valider les charges utiles réelles pour les combinaisons de requêtes dont votre produit dépend.
Portée de capture
Context de requête, page source utile.
L'enveloppe conserve les métadonnées de recherche soumises à côté de la charge utile du résultat DuckDuckGo afin que votre pipeline puisse conserver la provenance dont elle a besoin.
Leur valeur
Pays et langue
Exploiter la recherche avec une valeur locale combinée documentée.
Présentation
Langue d'interface
Définir le langage utilisé par les commandes et les étiquettes DuckDuckGo.
Politique
Recherche sécurisée
Choisissez un niveau de recherche de sécurité documenté pour la demande.
Récemment
Temps de travail
Demandez une fenêtre de jour, de semaine, de mois ou d'année, ou omettez le filtre.
Présentation
Appareil
Sélectionnez un contexte de périphérique documenté pour la page de résultats demandée.
Ensemble de filtres documentés
Configurez votre requête
Commencez par la requête requise. Ajoutez uniquement les filtres DuckDuckGo optionnels qui appartiennent à l'observation que vous avez l'intention de reproduire.
qRéservéRecherche de requête
Fournir les termes que DuckDuckGo devrait rechercher et encoder les espaces URL ou les caractères spéciaux.
klFacultatifPays + langue
Utilisez un code local combiné documenté, comme en_US, lorsque la demande a besoin de ce contexte.
kadFacultatifLangue d'interface
Choisissez la langue documentée pour les commandes et les étiquettes DuckDuckGo.
kpFacultatifNiveau de recherche en toute sécurité
S'allumer, modérer ou désactiver avec la valeur numérique documentée.
dfFacultatifTemps de travail
Limitez les résultats au jour, à la semaine, au mois ou à l'année précédentes, ou omettez le filtre pour tout moment.
deviceFacultatifContext de l'appareil
Sélectionnez une valeur de périphérique documentée lorsque le contexte de présentation demandé est important.
Réponse de la charge utile de la source
Traitez l'enveloppe JSON comme une limite de transport et non comme votre modèle d'enregistrement final.
La réponse du point d'extrémité est une enveloppe JSON contenant des métadonnées de requête et la charge utile HTML SERP source. Votre application possède l'extraction, la validation et la maintenance du schéma.
Forme documentée
JSONMetadata à côté de la charge utile
{
"search_parameters": {
"search_engine": "duckduckgo",
"query": "privacy research"
},
"search_results": "<html>...source SERP HTML...</html>"
}La présence des champs et la marque de source peuvent changer.
De la requête à l’enregistrement maintenu
De la requête au résultat
- 01Définir le contexte
Sélectionnez la requête et uniquement les filtres documentés requis par l'observation.
- 02Envoyer et valider
Appeler le côté serveur, inspecter l'état HTTP, et confirmer l'enveloppe de charge utile source attendue.
- 03Extrait et version
Appliquez vos règles testées, validez les champs requis et attachez votre version de schéma.
L'intégration
Connectez-vous depuis votre serveur
Gardez les informations de référence du côté du serveur, les valeurs de demande de code d'URL, définissez un délai limité, inspectez les états HTTP infructueux et validez l'enveloppe avant l'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- Le secret
WSA_API_KEYreste côté serveur- Moteur
engine=duckduckgo- Exemple de filtre
kl=en_US- Consommateur
Vérifiez l'état, l'enveloppe, puis la source
Cas d'utilisation de la source
Utilisez des captures contrôlées lorsque votre équipe a besoin de son propre contrat d'extraction.
Observation de la rechercheExplore SERP monitoringÉtude de marchéExplore market researchLa visibilité de la marqueExplore brand protectionContrat de donnéesReview search data
Recherche de la visibilité contrôlée
Capturez des pages sources DuckDuckGo comparables, puis déduisez les champs et les états de qualité que votre modèle de surveillance exige.
Révision de la source et du sujet
Conservez les données de source pour les groupes de requêtes et appliquez vos propres règles de classification, d'examen et de schéma.
Vérifie le domaine et la mention
Extraire des signaux approuvés des charges utiles contrôlées tout en conservant l'interprétation et l'escalade avec votre demande.
Enregistrements SERP modifiés
Définir le schéma, l'origine, les états de validation et la politique de conservation requises au-delà de la capture du temps de demande.
Choix de produit
Comparez vos options
Accès au réseauProduit courant Livraison gérée
Infrastructure de proxys
Votre équipe construit le client de recherche, logique de récupération, extraction et modèle de réponse.
La majorité des propriétaires de l'application Récupération de pageAPI de scraping
Envoyez une URL de page publique admissible et possédez la couche complète d'extraction et de schéma.
Accès à Internet généralAPI de recherche du DuckDuckGo
Envoyez le contexte de recherche documenté et recevez les métadonnées plus source SERP HTML à l'intérieur d'une enveloppe JSON.
Données gérées
Exploiter un ensemble de requêtes convenu, la cadence, le schéma, le processus de qualité et la livraison avec WebScrapingAPI.
Modèle d'exploitation convenuÉvaluation de la production
Obtenez un devis adapté à votre charge de travail
Les contextes de comptage et le travail de maintenance sont conjoints.
Questions
Ensembles de filtres
Fréquence de fonctionnement
Tests d'extraction
Il s’agit d’un modèle d’évaluation, pas d’une formule de facturation. Intégrez la conservation des sources, la validation de schéma et la gestion des changements de mise en page dans votre conception de production.
FAQ
Questions sur le produit
Qu'est-ce que le DuckDuckGo Retour API de recherche retourne ?
Le point final renvoie une enveloppe JSON contenant les métadonnées de la demande et la charge utile HTML SERP source. Il ne définit pas votre schéma d'enregistrement en aval; votre application possède l'extraction et la maintenance du schéma.
Qui est propriétaire de l'extraction quand la mise en page du DuckDuckGo change ?
Votre équipe possède des règles d'extraction, de validation et de maintenance de schéma pour la charge utile HTML SERP source. Lorsque DuckDuckGo modifie sa page, testez votre extracteur contre les réponses représentatives avant de promouvoir les changements.
Quels filtres du DuckDuckGo puis-je contrôler ?
Les commandes documentées utilisées sur cette page sont q pour la requête, kl pour le pays et la langue, kad pour la langue d'interface, kp pour la recherche sécurisée et df pour une plage de temps.
La charge source est-elle déjà conçue selon mon schéma ?
Non. La réponse conserve la charge utile du SERP HTML source à l'intérieur d'une enveloppe JSON. Votre application décide quels champs extraire, comment les modéliser et comment versionner le schéma résultant.
Comment ma demande doit-elle traiter les demandes qui ne réussissent pas ?
Vérifiez l'état HTTP avant de lire le corps, conservez suffisamment de contexte de requête pour enquêter sur les défaillances et utilisez un comportement de réessayer limité approprié à votre flux de travail.
Quand devrais-je prendre en compte le Données gérées à la place ?
Choisissez l'API lorsque votre équipe veut capturer le temps de demande et exploitera l'extraction, le schéma, le stockage et la planification. Considérez Données gérées lorsque vous souhaitez étendre un ensemble de requêtes convenu, la cadence, le schéma, le processus de qualité et la livraison avec WebScrapingAPI.
Votre première capture de source
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.