API de búsqueda de DuckDuckGo · punto final de carga de fuente
DuckDuckGo API de búsqueda para captura controlada de SERP.
Configure una consulta y filtros documentados de DuckDuckGo, luego reciba un sobre JSON que contiene metadatos de solicitud y la carga útil de HTML SERP fuente. Su aplicación posee extracción, validación y mantenimiento de esquema.
Solicitud de GET del lado del servidor ·engine=duckduckgo · Discuta su flujo de trabajo de datos fuente
- Control de búsqueda enfocadoEncuesta, localización, interfaz, seguridad, hora
- Fuente conservadaHTML SERP llevado en JSON
- Propiedad explícitaSu extractor, esquema y validación
- Contexto adjuntoSolicitar metadatos junto a la carga útil
Web data workflow · duckduckgo searchReady
kl en_US
kad en_US
kp -1
moderate
fielddf m
stackContrato de captura de DuckDuckGo
stackManifesto de filtro
stackInvestigación de privacidad
stacken_US
Una entrega clara
Captura la respuesta de la fuente sin borrar quién es el propietario del modelo de datos.
WebScrapingAPI opera el camino documentado de solicitud de DuckDuckGo. Su aplicación recibe la carga útil de origen y decide cómo extraer, validar, versionar, almacenar y usarla.
01
Limitar la observación
Mantenga la consulta, la localización, el lenguaje de interfaz, el nivel de búsqueda segura, el rango de tiempo y el dispositivo junto a cada captura.
02
Mantenga la fuente
Reciba la carga útil de HTML SERP de origen dentro de un envase JSON en lugar de asumir un esquema fijo en el torrente descendente.
03
Diseña tu extractor
Seleccione sólo los campos que su flujo de trabajo necesita y valide contra cargas útiles representativas.
04
Cambios en el diseño de la versión
Trate las reglas de extracción y registros como código de aplicación que su equipo prueba y mantiene.
WebScrapingAPIEjecución documentada de la solicitud
Frontera de respuestaMetadatos + fuente de SERP HTML
Su solicitudExtracción + mantenimiento del esquema
Buscar en la web
Un punto final enfocado para las observaciones controladas de la fuente-SERP.
Utilice el motor DuckDuckGo para las solicitudes de búsqueda web con la familia de filtros documentados. Valida las cargas útiles reales para las combinaciones de consultas de las que depende su producto.
Alcance de captura
Encuesta de contexto, página fuente de carga útil fuera.
El sobre mantiene metadatos de búsqueda presentados junto a la carga útil de resultados de DuckDuckGo para que su tubería pueda conservar la procedencia que necesita.
En el lugar
País y idioma
Exploitar la búsqueda con un valor local combinado documentado.
Presentación
Lenguaje de interfaz
Establezca el lenguaje utilizado por los controles y etiquetas de DuckDuckGo.
Política de seguridad
Busca segura
Seleccione un nivel de búsqueda de seguridad documentado para la solicitud.
Recientes
Rango de tiempo
Solicite un registro de día, semana, mes o año, o omita el filtro.
Presentación
Dispositivo
Seleccione un contexto de dispositivo documentado para la página de resultados solicitada.
Límites de cobertura:DuckDuckGo puede cambiar los campos y marcas expuestas por su página. Prueba cargas útiles representativas y mantener suposiciones de extracción dentro de una versión de consumo propiedad del cliente.
Setión de filtros documentados
Haga que el contexto de la búsqueda sea explícito antes de comparar capturas.
Comience con la consulta requerida. Añade sólo los filtros opcionales de DuckDuckGo que pertenecen a la observación que pretende reproducir.
q Required
Encuesta de búsqueda
Proporcionar los términos que DuckDuckGo debe buscar y codificar espacios de URL o caracteres especiales.
kl Optional
País + idioma
Utilice un código local combinado documentado, como en_US, cuando la solicitud necesite ese contexto.
kad Optional
Lenguaje de interfaz
Seleccione el idioma documentado para los controles y etiquetas de DuckDuckGo.
kp Optional
Nivel de búsqueda segura
Se activa, se modera o se desactiva con el valor numérico documentado.
df Optional
Rango de tiempo
Limite los resultados al día, semana, mes o año pasado, o omita el filtro para cualquier momento.
device Optional
Contexto del dispositivo
Seleccione un valor de dispositivo documentado cuando el contexto de presentación solicitado sea importante.
Parámetro fuente de verdadConfirmar los valores aceptados antes de su uso en producción.
Respuesta de carga de utilidad de la fuente
Trate el envase JSON como un límite de transporte, no como su modelo de registro final.
La respuesta de los puntos finales es un envase JSON que contiene metadatos de solicitud y la carga útil de HTML de SERP fuente. Su aplicación posee extracción, validación y mantenimiento de esquema.
Forma documentada
Metadatos junto a la carga útil
JSON
{
"search_parameters": {
"search_engine": "duckduckgo",
"query": "privacy research"
},
"search_results": "<html>...source SERP HTML...</html>"
}La presencia de campo y el marcado de la fuente pueden cambiar. Almacenar e inspeccionar sólo lo que su flujo de trabajo necesita.
Contrato de consumo
Su equipo define la capa estable.
Inspección
Compruebe el resultado HTTP y los campos de sobre esperados.
Extracto
Lea los elementos requeridos por su caso de uso en curso.
Validación
Distinguir contenido ausente, marcado cambiado y extracción fallida.
Versión
Registrar versiones de extractor y esquema con datos derivados.
Regla de propiedad
WebScrapingAPI devuelve el sobre documentado. Su aplicación posee cualquier extracción de la carga útil de HTML SERP fuente y el mantenimiento de cada contrato de campo a continuación.
Solicitud de registro
Construir el ciclo de vida de captura y extracción como etapas separadas.
Mantener la respuesta del punto final separada de su esquema de negocio hace que sea más fácil razonar sobre la propiedad, la validación y el manejo de cambios de diseño.
- 01
Define el contexto
Seleccione la consulta y solo los filtros documentados requeridos por la observación.
- 02
Enviar y validar
Llame al lado del servidor, inspeccione el estado HTTP y confirme el envase de carga útil de la fuente esperado.
- 03
Extracto y versión
Aplique sus reglas probadas, valida los campos requeridos y adjunta su versión de esquema.
La integración
Comience con una solicitud de DuckDuckGo y un camino de falla explícito.
Mantenga las credenciales en el lado del servidor, los valores de solicitud de código de URL, establezca un tiempo límite, inspeccione los estados HTTP fallidos y valide el sobre antes de extraer.
Breve solicitud
Prueba el contexto que su consumidor mantendrá.
Comience con una consulta representativa y un conjunto de filtros documentados. Guarde la carga útil de la fuente por separado de los registros derivados mientras el extractor está bajo prueba.
- Secreto
WSA_API_KEYpermanece en el lado del servidor- El motor
engine=duckduckgo- Ejemplo de filtro
kl=en_US- El consumidor
- Verifique el estado, sobre, luego fuente
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.bodyCasos de uso de origen
Utilice capturas controladas cuando su equipo necesite su propio contrato de extracción.
La carga útil de la fuente es una entrada, no una decisión terminada.
Observación de búsqueda
Investigación controlada de la visibilidad
Captura páginas de origen comparables de DuckDuckGo, luego deriva los campos y estados de calidad que requiere tu modelo de monitoreo.
Explorar el seguimiento de SERP →
Investigación de mercado
Revisar la fuente y el tema
Mantenga la evidencia de la fuente para los grupos de consultas y aplique sus propias reglas de clasificación, revisión y esquema.
Explorar la investigación de mercado →
Visibilidad de la marca
Control de dominio y mención
Extraer señales aprobadas de cargas útiles controladas mientras mantiene la interpretación y la escalada con su solicitud.
Explorar la protección de la marca
Contrato de datos
Registros de SERP con versión
Definir el esquema, procedencia, estados de validación y política de retención requeridos más allá de la captura del tiempo de solicitud.
Revisar los datos de búsqueda →
Selección de producto
Elige por cuánto del flujo de trabajo de fuente a esquema quieres poseer.
DuckDuckGo Search API maneja la solicitud documentada del motor y el envase de carga útil de la fuente. Los productos adyacentes cambian la responsabilidad hacia la infraestructura de acceso o la entrega Datos gestionados.
Infraestructura de proxies
Su equipo construye el cliente de búsqueda, lógica de recuperación, extracción y modelo de respuesta.
API de scraping
Envía una URL de página pública elegible y posee la capa completa de extracción y esquema.
DuckDuckGo API de búsqueda
Envía contexto de búsqueda documentado y recibe metadatos plus fuente de SERP HTML dentro de un envase JSON.
Datos gestionados
Obtenga un conjunto de consultas acordado, cadencia, esquema, proceso de calidad y entrega con WebScrapingAPI.
Evaluamiento de la producción
Valida el ajuste de carga útil antes de seleccionar un plan.
Prueba casos ordinarios, localizados, filtrados en tiempo, vacíos, de diseño cambiado y fallidos.
Matriz de evaluación
Cuenta los contextos y el trabajo de mantenimiento juntos.
Formula de carga de trabajo ilustrativa
Las preguntas × Setios de filtros × Frecuencia de ejecución + Pruebas de extracción
Este es un modelo de evaluación, no una fórmula de facturación. Incluya la retención de la fuente, la validación del esquema y el manejo de cambios de diseño en su diseño de producción.
Preguntas en directo
- Contexto
¿Qué combinaciones de filtros importan?
- Contrato
¿Qué campos de origen deben estar presentes?
- Calidad
¿Cómo se detectan los cambios en la marcación?
- Recuperación
¿Qué fallas se pueden volver a intentar?
- Propiedad
¿Quién mantiene el extractor y el esquema?
FAQ
DuckDuckGo Busca API preguntas para una evaluación basada.
Utilice la documentación actual y las cargas útiles representativas de las fuentes como fuente de verdad de implementación.
¿Qué devuelve la API de búsqueda de DuckDuckGo?
El punto final devuelve un envase JSON que contiene metadatos de solicitud y la carga útil de HTML de origen SERP. No define su esquema de registro en el torrente descendente; su aplicación posee la extracción y el mantenimiento del esquema.
¿Quién es el dueño de la extracción cuando el diseño de DuckDuckGo cambia?
Su equipo posee reglas de extracción, validación y mantenimiento de esquemas para la carga útil de HTML de SERP fuente. Cuando DuckDuckGo cambie su página, teste su extractor contra respuestas representativas antes de promover cambios.
¿Qué filtros DuckDuckGo puedo controlar?
Los controles documentados utilizados en esta página son q para la consulta, kl para el país y el idioma, kad para el idioma de interfaz, kp para la búsqueda segura y df para un rango de tiempo. Elimine los filtros opcionales que no necesita.
¿La carga de origen ya está conformada a mi esquema?
No. La respuesta conserva la carga útil del HTML SERP de origen dentro de un envase JSON. Su aplicación decide qué campos extraer, cómo modelarlos y cómo versionar el esquema resultante.
¿Cómo debería manejar mi solicitud si no se cumplen?
Verifique el estado HTTP antes de leer el cuerpo, mantenga el contexto de la solicitud suficiente para investigar los fallos y use el comportamiento de retoma limitado apropiado para su flujo de trabajo.
¿Cuándo debería considerar el Datos gestionados en su lugar?
Elige la API cuando tu equipo desee capturar el tiempo de solicitud y operará extracción, esquema, almacenamiento y programación. Considere Datos gestionados cuando quieras abarcar un conjunto de consultas acordado, cadencia, esquema, proceso de calidad y entrega con WebScrapingAPI.
Tu primera captura de fuentes
Prueba una consulta DuckDuckGo contra el esquema que tu equipo tiene la intención de mantener.
Comience con el punto final documentado, o hable con nuestro equipo sobre un flujo de trabajo acordado Datos gestionados.