Limitar a observação
Mantenha a consulta, localização, linguagem de interface, nível de busca segura, intervalo de tempo e dispositivo ao lado de cada captura.
API de pesquisa DuckDuckGo para captura de SERP
Capture o HTML das páginas de busca do DuckDuckGo em uma resposta JSON. Defina a consulta e os filtros e extraia os campos que sua aplicação precisa.
Uma transferência clara
Capture a página de origem e controle a extração
Reter a fonte
Receba a carga útil do HTML SERP de origem dentro de um envelope JSON em vez de assumir um esquema fixo a jusante.
Desenhe o seu extrator
Selecione apenas os campos que o seu fluxo de trabalho precisa e valida-os contra cargas úteis representativas.
Mudanças no layout da versão
Trate as regras de extracção e os esquemas de registro como código de aplicação que sua equipe teste e mantém.
WebScrapingAPIExecução documentada de pedidos
Limite de respostaMetadados + fonte SERP HTML
O seu pedidoExtração + manutenção de esquema
Pesquisa na web DuckDuckGo
Um ponto final focado para observações controladas de fontes-SERP.
Use o motor DuckDuckGo para pesquisas na web com a família de filtros documentados. Validear cargas úteis reais para as combinações de consulta que o seu produto depende.
Ámbito de captura
Queria conteúdo, página fonte de carga útil.
O envelope mantém os metadados de busca submetidos adjacentes à carga útil de resultados do DuckDuckGo para que o seu pipeline possa manter a proveniência que precisa.
Localização
País e língua
Escala a pesquisa com um valor local combinado documentado.
Presentação
Língua de interface
Defina a linguagem utilizada pelos controles e rótulos do DuckDuckGo.
Política
Pesquisa segura
Escolha um nível de busca de segurança documentado para o pedido.
Recentes
Intervalo de tempo
Solicite uma janela documentada de dia, semana, mês ou ano, ou omita o filtro.
Presentação
Dispositivo
Selecione um contexto de dispositivo documentado para a página de resultados solicitada.
Set de filtros documentados
Configure sua solicitação
Comece com a consulta necessária. Adicione apenas os filtros opcionais DuckDuckGo que pertencem à observação que pretende reproduzir.
qRequeridoPesquisa de pesquisa
Fornecer os termos que o DuckDuckGo deve procurar e codificar espaços ou caracteres especiais em URL.
klOpcionalPaís + língua
Use um código local combinado documentado, como en_US, quando o pedido precisar desse contexto.
kadOpcionalLíngua de interface
Escolha a linguagem documentada para os controles e rótulos do DuckDuckGo.
kpOpcionalNível de busca segura
Ativar, moderar ou desativar com o valor numérico documentado.
dfOpcionalIntervalo de tempo
Limite os resultados ao dia, semana, mês ou ano passado, ou omita o filtro para qualquer momento.
deviceOpcionalContexto do dispositivo
Selecione um valor de dispositivo documentado quando o contexto de apresentação solicitado for importante.
Resposta à carga de serviço da fonte
Trate o envelope JSON como um limite de transporte, não como seu modelo de registro final.
A resposta do endpoint é um envelope JSON contendo metadados de solicitação e a carga útil do HTML SERP fonte.
Forma documentada
JSONMetadados ao lado da carga útil
{
"search_parameters": {
"search_engine": "duckduckgo",
"query": "privacy research"
},
"search_results": "<html>...source SERP HTML...</html>"
}A presença de campo e a marcação da fonte podem mudar.
Da solicitação ao registro mantido
Da solicitação ao resultado
- 01Defina o contexto
Selecione a consulta e apenas os filtros documentados necessários à observação.
- 02Enviar e validar
Ligue para o lado do servidor, inspecione o status HTTP e confirme o envelope de carga útil da fonte esperado.
- 03Extracto e versão
Aplique as regras testadas, valida os campos necessários e anexe a versão do esquema.
Integração
Conecte pelo seu servidor
Mantenha as credenciais do lado do servidor, os valores de solicitação de código de URL, defina um prazo limitado, insira estados HTTP falhos e valida o envelope antes da extração.
: "${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- Segredo
WSA_API_KEYpermanece do lado do servidor- Motor
engine=duckduckgo- Exemplo de filtro
kl=en_US- Consumidor
Verifique o estado, envelope, e depois fonte
Caso de utilização de origem
Use captura controlada quando a sua equipa precisar de um contrato de extracção.
Observação de pesquisaExplore SERP monitoringPesquisa de mercadoExplore market researchVisível da marcaExplore brand protectionContrato de dadosReview search data
Pesquisa controlada de visibilidade
Capture comparable DuckDuckGo páginas de origem, em seguida, derivar os campos e estados de qualidade que o seu modelo de monitoramento requer.
Revisão da fonte e do tópico
Manter evidências de origem para grupos de consulta e aplicar suas próprias regras de classificação, revisão e esquema.
Controlos de domínio e menção
Extrair sinais aprovados de cargas úteis controladas, mantendo a interpretação e a escalada com a sua aplicação.
Registros de SERP em versão
Defina o esquema, a proveniência, os estados de validação e a política de retenção necessários para além da captura do tempo de solicitação.
Selecção do produto
Compare suas opções
Acesso à redeProduto corrente Entrega gerenciada
Infraestrutura de proxies
A sua equipa constrói o cliente de busca, lógica de recuperação, extração e modelo de resposta.
A maioria das aplicações Retorno de páginaAPI de scraping
Enviar um URL de página pública elegível e possuir a camada completa de extração e esquema.
Acesso geral à webDuckDuckGo API de pesquisa
Enviar conteúdo de pesquisa documentado e receber metadados plus fonte SERP HTML dentro de um envelope JSON.
Dados geridos
Escolher um conjunto de consultas acordado, cadência, esquema, processo de qualidade e entrega com WebScrapingAPI.
Modelo de funcionamento acordadoAvaliação da produção
Obtenha um orçamento para sua carga de trabalho
Contar contextos e trabalhar em manutenção juntos.
Questões
Sete de filtros
Frequência de execução
Testes de extracção
Este é um modelo de avaliação, não uma fórmula de faturamento. Incluir retenção de fonte, validação de esquema e manipulação de mudanças de layout no seu projeto de produção.
FAQ
Perguntas sobre o produto
O que é que a API de Pesquisa do DuckDuckGo retorna?
O endpoint retorna um envelope JSON contendo metadados de solicitação e a carga útil de HTML SERP fonte. Não define o seu esquema de registro descendente; seu aplicativo possui extração e manutenção de esquema.
Quem é o dono da extracção quando o layout do DuckDuckGo muda?
Sua equipe possui regras de extração, validação e manutenção de esquema para a carga útil de HTML da fonte do SERP. Quando o DuckDuckGo muda sua página, teste o extractor contra respostas representativas antes de promover alterações.
Que filtros DuckDuckGo posso controlar?
Os controles documentados utilizados nesta página são q para a consulta, kl para o país e idioma, kad para a linguagem de interface, kp para a pesquisa segura e df para um intervalo de tempo.
A carga de fonte já está moldada para o meu esquema?
Não. A resposta preserva a carga útil do HTML SERP fonte dentro de um envelope JSON. Seu aplicativo decide quais campos extrair, como modelar e como versionar o esquema resultante.
Como deve o meu pedido lidar com os pedidos não bem-sucedidos?
Verifique o status HTTP antes de ler o corpo, retenha conteúdo suficiente para investigar falhas e use o comportamento de retestamento limitado adequado ao seu fluxo de trabalho.
Quando devo considerar o Dados geridos em vez disso?
Escolha a API quando a sua equipe quiser capturar o tempo de solicitação e operará extração, esquema, armazenamento e agendamento. Considere Dados geridos quando quiser abranger um conjunto de consultas acordado, cadência, esquema, processo de qualidade e entrega com WebScrapingAPI.
A sua primeira captura de fontes
Planeje sua coleta de dados de busca
Compartilhe buscador, consultas, mercados e frequência. Confirmaremos o formato de resposta e o preço para sua carga de trabalho.