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.
API de búsqueda de DuckDuckGo para captura de SERP
Captura el HTML de las páginas de búsqueda de DuckDuckGo en una respuesta JSON. Define la consulta y los filtros y extrae los campos que necesita tu aplicación.
Una entrega clara
Captura la página de origen y controla la extracción
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.
Diseña tu extractor
Seleccione sólo los campos que su flujo de trabajo necesita y valide contra cargas útiles representativas.
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.
Setión de filtros documentados
Configura tu solicitud
Comience con la consulta requerida. Añade sólo los filtros opcionales de DuckDuckGo que pertenecen a la observación que pretende reproducir.
qRequeridoEncuesta de búsqueda
Proporcionar los términos que DuckDuckGo debe buscar y codificar espacios de URL o caracteres especiales.
klOpcionalPaís + idioma
Utilice un código local combinado documentado, como en_US, cuando la solicitud necesite ese contexto.
kadOpcionalLenguaje de interfaz
Seleccione el idioma documentado para los controles y etiquetas de DuckDuckGo.
kpOpcionalNivel de búsqueda segura
Se activa, se modera o se desactiva con el valor numérico documentado.
dfOpcionalRango de tiempo
Limite los resultados al día, semana, mes o año pasado, o omita el filtro para cualquier momento.
deviceOpcionalContexto del dispositivo
Seleccione un valor de dispositivo documentado cuando el contexto de presentación solicitado sea importante.
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
JSONMetadatos junto a la carga útil
{
"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.
De la solicitud al registro mantenido
De la solicitud al resultado
- 01Define el contexto
Seleccione la consulta y solo los filtros documentados requeridos por la observación.
- 02Enviar y validar
Llame al lado del servidor, inspeccione el estado HTTP y confirme el envase de carga útil de la fuente esperado.
- 03Extracto y versión
Aplique sus reglas probadas, valida los campos requeridos y adjunta su versión de esquema.
La integración
Conecta desde tu servidor
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.
: "${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- 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
Casos de uso de origen
Utilice capturas controladas cuando su equipo necesite su propio contrato de extracción.
Observación de búsquedaExplore SERP monitoringInvestigación de mercadoExplore market researchVisibilidad de la marcaExplore brand protectionContrato de datosReview search data
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.
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.
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.
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.
Selección de producto
Compara tus opciones
Acceso a la redProducto actual Entrega gestionada
Infraestructura de proxies
Su equipo construye el cliente de búsqueda, lógica de recuperación, extracción y modelo de respuesta.
La mayoría de las aplicaciones Recuperación de páginasAPI de scraping
Envía una URL de página pública elegible y posee la capa completa de extracción y esquema.
Acceso general a la webDuckDuckGo 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.
Modelo de operación acordadoEvaluamiento de la producción
Obtén un presupuesto para tu carga de trabajo
Cuenta los contextos y el trabajo de mantenimiento juntos.
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.
FAQ
Preguntas sobre el producto
¿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
Planifica tu recopilación de datos de búsqueda
Comparte el buscador, consultas, mercados y frecuencia. Confirmaremos el formato de respuesta y el precio para tu carga de trabajo.