API de recherche DuckDuckGo · point final de charge de source
DuckDuckGo API de recherche pour la capture contrôlée du SERP.
Configurez une requête et des filtres DuckDuckGo documentés, puis recevez une enveloppe JSON contenant les métadonnées de la requête et la charge utile HTML SERP source. Votre application possède l'extraction, la validation et la maintenance du schéma.
Demande de GET du côté du serveur ·engine=duckduckgo · Discutez de votre flux de travail de source-données
- Contrôles de recherche cibléesRequête, localité, interface, sécurité, heure
- La source conservéeLe code HTML SERP est porté en JSON
- Propriété expliciteVotre extracteur, votre schéma et votre validation
- Contextes jointsDemande de métadonnées à côté de la charge utile
Web data workflow · duckduckgo searchReady
kl en_US
kad en_US
kp -1
moderate
fielddf m
stackLe contrat de capture du DuckDuckGo
stackManifeste de filtrage
stackrecherche sur la vie privée
stacken_US
Une transmission claire
Capturez la réponse de la source sans flouer qui est le propriétaire du modèle de données.
WebScrapingAPI exploite le chemin de demande documenté DuckDuckGo. Votre application reçoit la charge utile source et décide comment l'extraire, valider, la version, le stockage et l'utilisation.
01
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.
02
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.
03
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.
04
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.
Limite de couverture:DuckDuckGo peut modifier les champs et les balises exposés par sa page.
Ensemble de filtres documentés
Faites le contexte de recherche explicite avant de comparer les captures.
Commencez par la requête requise. Ajoutez uniquement les filtres DuckDuckGo optionnels qui appartiennent à l'observation que vous avez l'intention de reproduire.
q Required
Recherche de requête
Fournir les termes que DuckDuckGo devrait rechercher et encoder les espaces URL ou les caractères spéciaux.
kl Optional
Pays + langue
Utilisez un code local combiné documenté, comme en_US, lorsque la demande a besoin de ce contexte.
kad Optional
Langue d'interface
Choisissez la langue documentée pour les commandes et les étiquettes DuckDuckGo.
kp Optional
Niveau de recherche en toute sécurité
S'allumer, modérer ou désactiver avec la valeur numérique documentée.
df Optional
Temps 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.
device Optional
Context de l'appareil
Sélectionnez une valeur de périphérique documentée lorsque le contexte de présentation demandé est important.
Paramètre source de véritéConfirmer les valeurs acceptées avant utilisation en production.
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
Metadata à côté de la charge utile
JSON
{
"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.
Contrats de consommation
Votre équipe définit la couche stable.
Inspection
Vérifiez les résultats HTTP et les champs de l'enveloppe attendue.
Extrait
Lisez les éléments requis par votre cas d'utilisation en aval.
Validation
Distinguer le contenu absent, la marque modifiée et l'extraction ratée.
Version
Enregistrer les versions extracteur et schéma avec les données dérivées.
Règle de propriété
WebScrapingAPI renvoie l'enveloppe documentée. Votre application possède toute extraction de la charge utile HTML SERP source et la maintenance de chaque contrat de champ en aval.
Demande de conservation des dossiers
Construisez le cycle de vie de capture et d'extraction en étapes distinctes.
Garder la réponse du point final séparée de votre schéma d'entreprise facilite la prise en compte de la propriété, de la validation et du traitement des changements de mise en page.
- 01
Définir le contexte
Sélectionnez la requête et uniquement les filtres documentés requis par l'observation.
- 02
Envoyer et valider
Appeler le côté serveur, inspecter l'état HTTP, et confirmer l'enveloppe de charge utile source attendue.
- 03
Extrait et version
Appliquez vos règles testées, validez les champs requis et attachez votre version de schéma.
L'intégration
Commencez par une demande DuckDuckGo et un chemin d'échec explicite.
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.
Rapport de demande
Testez le contexte que votre consommateur conservera.
Commencez par une requête représentative et un petit ensemble de filtres documentés.
- 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
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());: "${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"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());
}
}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());<?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;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())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.bodyCas d'utilisation de la source
Utilisez des captures contrôlées lorsque votre équipe a besoin de son propre contrat d'extraction.
La charge utile source est une entrée, pas une décision finie.
Observation de la recherche
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.
Explorez le suivi des SERP →
Étude de marché
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.
Explorer les études de marché →
La visibilité de la marque
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.
Explorer la protection de la marque →
Contrat de données
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.
Révision des données de recherche →
Choix de produit
Choisissez par le nombre de flux de travail de source à schéma que vous voulez posséder.
DuckDuckGo Search API gère la demande du moteur documentée et l'enveloppe de charge utile source. Les produits adjacents transfèrent la responsabilité vers l'infrastructure d'accès ou Données gérées livraison.
Infrastructure de proxys
Votre équipe construit le client de recherche, logique de récupération, extraction et modèle de réponse.
API de scraping
Envoyez une URL de page publique admissible et possédez la couche complète d'extraction et de schéma.
API 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.
Évaluation de la production
Valider l'ajustement de la charge utile avant de sélectionner un plan.
Les prix et les plans actuels restent la source commerciale de vérité.
Matrice d'évaluation
Les contextes de comptage et le travail de maintenance sont conjoints.
Formule illustrative de charge de travail
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.
Questions en direct
- Contextes
Quelles combinaisons de filtres comptent ?
- Contrat
Quels champs de source doivent être présents ?
- Qualité
Comment détecter les changements de marquage ?
- Récupération
Quelles échecs peuvent être réessayés?
- Propriété
Qui maintient l'extracteur et le schéma ?
FAQ
DuckDuckGo recherche API questions pour une évaluation à la terre.
Utilisez la documentation actuelle et les charges utiles représentatives des sources comme source de vérité de mise en œuvre.
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
Testez une requête DuckDuckGo contre le schéma que votre équipe a l'intention de maintenir.
Commencez par le point final documenté, ou parlez à notre équipe d'un flux de travail convenu Données gérées.