DuckDuckGo Search API · ponto final de carga de fonte
DuckDuckGo Search API para captura controlada de SERP.
Configure uma consulta e filtros documentados do DuckDuckGo, em seguida, receba um envelope JSON contendo metadados da solicitação e a carga útil do HTML SERP fonte.
Solicitação de GET do lado do servidor ·engine=duckduckgo · Discutir o seu fluxo de trabalho de dados fonte
- Controle de pesquisa focadoQuestão, local, interface, segurança, hora
- Fonte preservadaSERP HTML transportado em JSON
- Propriedade explícitaO seu extractor, esquema e validação
- Contexto anexoPedir metadados além da carga útil
Web data workflow · duckduckgo searchReady
kl en_US
kad en_US
kp -1
moderate
fielddf m
stackO contrato de captura do DuckDuckGo
stackManifesto de filtro
stackPesquisa de privacidade
stacken_US
Uma transferência clara
Capturar a resposta da fonte sem confundir quem é o proprietário do modelo de dados.
WebScrapingAPI opera o caminho documentado de solicitação do DuckDuckGo. A sua aplicação recebe a carga útil fonte e decide como extraí-la, validá-la, versão, armazená-la e usá-la.
01
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.
02
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.
03
Desenhe o seu extrator
Selecione apenas os campos que o seu fluxo de trabalho precisa e valida-os contra cargas úteis representativas.
04
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.
Limite de cobertura:O DuckDuckGo pode alterar os campos e marcas expostas por sua página.
Set de filtros documentados
Faça o contexto da pesquisa explícito antes de comparar capturas.
Comece com a consulta necessária. Adicione apenas os filtros opcionais DuckDuckGo que pertencem à observação que pretende reproduzir.
q Required
Pesquisa de pesquisa
Fornecer os termos que o DuckDuckGo deve procurar e codificar espaços ou caracteres especiais em URL.
kl Optional
País + língua
Use um código local combinado documentado, como en_US, quando o pedido precisar desse contexto.
kad Optional
Língua de interface
Escolha a linguagem documentada para os controles e rótulos do DuckDuckGo.
kp Optional
Nível de busca segura
Ativar, moderar ou desativar com o valor numérico documentado.
df Optional
Intervalo de tempo
Limite os resultados ao dia, semana, mês ou ano passado, ou omita o filtro para qualquer momento.
device Optional
Contexto do dispositivo
Selecione um valor de dispositivo documentado quando o contexto de apresentação solicitado for importante.
Parâmetro fonte de verdadeConfirmar os valores aceitos antes da utilização em produção.
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
Metadados ao lado da carga útil
JSON
{
"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.
Contrato de consumo
A sua equipa define a camada estável.
Inspecção
Verifique o resultado HTTP e os campos de envelope esperados.
Extracto
Leia os elementos exigidos pelo seu caso de utilização a jusante.
Validação
Distinguir o conteúdo ausente, marcado alterado e extração falhada.
Versão
Registrar versões de extractor e esquema com dados derivados.
Regra de propriedade
WebScrapingAPI retorna o envelope documentado. Seu aplicativo possui qualquer extração da carga útil HTML SERP fonte e a manutenção de todos os contratos de campo a jusante.
Solicitação de registro
Construir o ciclo de vida de captura e extracção como etapas separadas.
Manter a resposta do endpoint separada do seu esquema de negócios torna a propriedade, validação e manejo de mudanças de layout mais fácil de raciocinar.
- 01
Defina o contexto
Selecione a consulta e apenas os filtros documentados necessários à observação.
- 02
Enviar e validar
Ligue para o lado do servidor, inspecione o status HTTP e confirme o envelope de carga útil da fonte esperado.
- 03
Extracto e versão
Aplique as regras testadas, valida os campos necessários e anexe a versão do esquema.
Integração
Comece com uma solicitação do DuckDuckGo e um caminho de falha explícito.
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.
Resumo do pedido
Teste o contexto que o seu consumidor irá manter.
Comece com uma consulta representativa e um pequeno conjunto de filtros documentados. Salve a carga útil da fonte separadamente dos registros derivados enquanto o extractor está sob teste.
- 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
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.bodyCaso de utilização de origem
Use captura controlada quando a sua equipa precisar de um contrato de extracção.
A carga útil da fonte é uma entrada, não uma decisão concluída. Preserva as versões de contexto e extractor das solicitações antes de comparar ou operationalizar os dados derivados.
Observação de pesquisa
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.
Explore o monitoramento do SERP →
Pesquisa de mercado
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.
Explorar a pesquisa de mercado →
Visível da marca
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.
Explora a protecção da marca
Contrato de dados
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.
Revisar os dados de pesquisa →
Selecção do produto
Escolha por quanto do fluxo de trabalho fonte-a-esquema que deseja possuir.
A API de Pesquisa DuckDuckGo lida com a solicitação documentada do motor e a enveloppa de carga útil da fonte. Os produtos adjacentes transferem a responsabilidade para a infraestrutura de acesso ou a entrega Dados geridos.
Infraestrutura de proxies
A sua equipa constrói o cliente de busca, lógica de recuperação, extração e modelo de resposta.
API de scraping
Enviar um URL de página pública elegível e possuir a camada completa de extração e esquema.
DuckDuckGo 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.
Avaliação da produção
Validar a adequação da carga útil antes de selecionar um plano.
Teste casos comuns, localizados, filtrados em tempo, vazios, alterados e falhos.
Matriz de avaliação
Contar contextos e trabalhar em manutenção juntos.
Formulha ilustrativa de carga de trabalho
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.
Perguntas em directo
- Contexto
Que combinações de filtros importam?
- Contrato
Quais são os campos de origem que devem estar presentes?
- Qualidade
Como são detectadas as alterações de marcação?
- Recuperação
Quais falhas podem ser tentadas novamente?
- Propriedade
Quem mantém o extractor e o esquema?
FAQ
DuckDuckGo Busca API perguntas para uma avaliação fundamentada.
Use a documentação atual e as cargas úteis representativas da fonte como a fonte de implementação da verdade.
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
Teste uma consulta DuckDuckGo contra o esquema que a sua equipa pretende manter.
Comece com o endpoint documentado, ou fale com a nossa equipa sobre um fluxo de trabalho acordado Dados geridos.