# DuckDuckGo Scraper — Search Results & SERP | No API Key (`bovi/duckduckgo-scraper`) Actor

Scrape DuckDuckGo search results into clean JSON — no API key, no login, no CAPTCHA. Run any list of queries, pick a region, get ranked organic results: title, URL, snippet, displayed URL, and rank. Auto-paginates to your result cap. Resilient parser emits a parse\_confidence per result.

- **URL**: https://apify.com/bovi/duckduckgo-scraper.md
- **Developed by:** [Vitalii Bondarev](https://apify.com/bovi) (community)
- **Categories:** SEO tools, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.53 / 1,000 search-results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## DuckDuckGo Scraper — Search Results & SERP

**Scrape DuckDuckGo search results into clean, structured JSON — no API key, no login, no CAPTCHA.** Feed the **DuckDuckGo Scraper** a list of search queries, pick a region, and get back ranked organic results: title, URL, snippet, displayed (breadcrumb) URL, and position. It paginates automatically until it hits your result cap, and every result carries a `parse_confidence` score so you know the data is good.

DuckDuckGo doesn't sell an official search API, and the unofficial ones are rate-capped or paywalled. This actor gives you DuckDuckGo SERP data on demand, billed per result, with a structural parser built to survive DuckDuckGo's HTML changes.

### What you get — DuckDuckGo SERP data per result

Each organic result in the output dataset includes:

| Field | Description |
|---|---|
| `rank` | 1-based organic position across all pages of the query |
| `title` | Result title (the clickable headline) |
| `url` | Destination URL (absolute, redirect-unwrapped) |
| `displayed_url` | The green breadcrumb URL shown under the title |
| `snippet` | The result description / preview text |
| `query` | The search query that produced this result |
| `region` | The DuckDuckGo region code used |
| `parse_confidence` | 0–1 parse-quality score (1.0 = clean) |
| `warnings` | Machine-readable codes if any field looked off |
| `scraped_at` | ISO-8601 UTC timestamp of the scrape |

### How to scrape DuckDuckGo search results

1. **Add your queries.** Put one or more search terms in **Search queries** (e.g. `best running shoes`, `python tutorial`). Each query runs separately. For a single one-off lookup you can use the **Single query** field instead — handy for Make / Zapier / n8n.
2. **Pick a region** (optional). Use a DuckDuckGo region code like `us-en` (United States), `uk-en`, `de-de`, `fr-fr`, `ru-ru`, or `wt-wt` for worldwide / no region (the default).
3. **Set Max results per query.** The actor paginates (~10 results per page) until it reaches your cap. Keep it low to control cost.
4. **Run it.** Results stream into the dataset in real time. Export as JSON, CSV, or Excel, or pull them via the Apify API.

### Why this DuckDuckGo Scraper is reliable

- **Resilient parser — the real edge.** Most search scrapers break the moment the target tweaks a CSS class. This one anchors on DuckDuckGo's stable result-anchor structure and emits a `parse_confidence` per result, so a markup drift surfaces loudly instead of silently shipping blank rows.
- **No API key, no login, no CAPTCHA.** It talks to DuckDuckGo's lightweight HTML results endpoint directly, with the `lite` endpoint as an automatic fallback.
- **Proxy built in.** DuckDuckGo soft-throttles a hammered IP. The actor uses Apify Proxy (RESIDENTIAL recommended) with per-query IP rotation and retries on a fresh IP, so runs stay reliable at volume. Proxy is billed to the run owner — no external proxy account to wire up.

### Input example

```json
{
  "queries": ["best running shoes", "python tutorial"],
  "region": "us-en",
  "maxResults": 30,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

### Output example

```json
{
  "rank": 1,
  "title": "The 15 Best Running Shoes of 2026 - Running Shoe Reviews",
  "url": "https://www.runnersworld.com/gear/a19663621/best-running-shoes/",
  "displayed_url": "www.runnersworld.com/gear/a19663621/best-running-shoes/",
  "snippet": "From cushioned and lightweight to comfy and stable, these are the best running shoes we're loving right now.",
  "query": "best running shoes",
  "region": "us-en",
  "parse_confidence": 1.0,
  "warnings": [],
  "scraped_at": "2026-06-05T12:00:00+00:00"
}
```

### Common use cases for DuckDuckGo SERP data

- **SEO rank tracking** — monitor where pages rank on DuckDuckGo for your target keywords, by region.
- **SERP research & content gaps** — pull the top results for a topic to see who's ranking and what they cover.
- **Lead generation** — turn a list of search queries into a list of candidate sites and URLs.
- **Brand & competitor monitoring** — track which domains surface for branded and category queries.
- **Privacy-friendly search data** — DuckDuckGo results without the personalization noise of logged-in search.

### Frequently asked questions

**Does this need a DuckDuckGo API key or account?**
No. There's no key, no login, and no CAPTCHA to solve.

**How many results per query can I get?**
Set **Max results per query**. The actor paginates automatically (~10 per page) until it reaches your cap.

**Which regions are supported?**
Any DuckDuckGo region code in `<country>-<lang>` form (e.g. `us-en`, `de-de`, `wt-wt`). DuckDuckGo validates it server-side.

**Why is a residential proxy recommended?**
DuckDuckGo soft-throttles IPs that send many requests. Apify RESIDENTIAL proxy rotates the IP per query so runs stay reliable. It's billed to the run owner.

**How am I charged?**
Pay-per-result: one charge per organic result returned. You only pay for data you actually get.

***

Built by the same team as our other search and lead-gen scrapers. Looking for Google instead? Pair this with our Google Search Scraper for cross-engine SERP coverage.

# Actor input Schema

## `queries` (type: `array`):

Search queries to run on DuckDuckGo (e.g. 'best running shoes', 'python tutorial'). Each query runs separately and returns its own ranked organic results.

## `query` (type: `string`):

Convenience: a single search query. Use this OR the Search queries list above (you can use both). Handy for one-off runs and Make/Zapier integrations.

## `region` (type: `string`):

DuckDuckGo region code as <country>-<lang>: us-en (US), uk-en (UK), de-de (Germany), fr-fr (France), ru-ru (Russia), wt-wt (worldwide, no region). Default: wt-wt.

## `maxResults` (type: `integer`):

Maximum organic results to return per query. The actor paginates automatically (~10 results per page) until it reaches this cap. Keep low to control cost.

## `pageSize` (type: `integer`):

How many results to push per batch for real-time output. Lower = faster first results; higher = fewer dataset writes.

## `proxyConfiguration` (type: `object`):

Apify Proxy. RECOMMENDED on the cloud: DuckDuckGo soft-throttles a hammered IP, so a RESIDENTIAL group with IP rotation keeps results flowing. Billed to the run owner — no external proxy account needed.

## Actor input object example

```json
{
  "queries": [
    "best running shoes",
    "python tutorial"
  ],
  "region": "wt-wt",
  "maxResults": 30,
  "pageSize": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset containing Duckduckgo Scraper records (rank, title, url, displayed\_url, snippet, query, region, parse\_confidence).

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "queries": [
        "best running shoes"
    ],
    "region": "wt-wt",
    "maxResults": 30,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("bovi/duckduckgo-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "queries": ["best running shoes"],
    "region": "wt-wt",
    "maxResults": 30,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("bovi/duckduckgo-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "queries": [
    "best running shoes"
  ],
  "region": "wt-wt",
  "maxResults": 30,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call bovi/duckduckgo-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=bovi/duckduckgo-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/eDY0GJiHNwZKO6uJ9/builds/QkhXy1dtWuN2bX1ZD/openapi.json