# DuckDuckGo Search Results Scraper (`fetch_cat/duckduckgo-search-results-scraper`) Actor

Export ranked DuckDuckGo organic search results for keywords, including title, URL, snippet, rank, region, page, and timestamp.

- **URL**: https://apify.com/fetch\_cat/duckduckgo-search-results-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** SEO tools, Marketing, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.06 / 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 Search Results Scraper

Scrape ranked DuckDuckGo organic search results for keywords and export clean SERP data to CSV, JSON, Excel, datasets, APIs, and automation workflows.

Use this actor when you need privacy-oriented search monitoring without depending only on Google or Bing SERP sources.

### What does DuckDuckGo Search Results Scraper do?

DuckDuckGo Search Results Scraper turns search terms into structured result rows.

It extracts organic result titles, destination URLs, visible URLs, snippets, ranks, region settings, page numbers, and extraction timestamps.

You can run one keyword, a list of keywords, or API-triggered searches from your own workflow.

The output is ready for SEO rank tracking, competitive research, content research, brand monitoring, and lightweight search automation.

### Who is it for?

SEO teams use it to monitor DuckDuckGo rankings for important keywords.

Content marketers use it to research which pages and snippets appear for topic clusters.

Developers use it to add private-search SERP data to automations.

Researchers use it to compare search visibility outside the Google ecosystem.

Agencies use it to deliver recurring CSV or API exports to clients.

### Why scrape DuckDuckGo search results?

DuckDuckGo has a distinct audience and ranking mix.

Tracking only Google can miss visibility changes on privacy-focused search.

DuckDuckGo SERPs are also useful for monitoring neutral web results, competitive landing pages, and long-tail topic coverage.

This actor gives you repeatable exports rather than manual copy-paste.

### Output fields

| Field | Description |
| --- | --- |
| `query` | Search query that produced the result |
| `rank` | Organic rank for the query |
| `title` | Result title |
| `url` | Decoded destination URL |
| `displayUrl` | Visible URL shown in the result |
| `snippet` | Result description snippet |
| `redirectUrl` | DuckDuckGo redirect URL when present |
| `region` | DuckDuckGo region code used |
| `page` | Search results page number |
| `scrapedAt` | ISO timestamp for extraction |

### Pricing

This Actor uses Apify pay-per-event pricing. The prices below come from the current Actor pricing configuration. Apify public plans map to Store discount tiers, so the table shows both the user-facing plan context and the pricing tier name. The final price shown in Apify depends on the user account plan and any custom agreement.

| Event | What is charged | Price |
| --- | --- | ---: |
| `start` | One-time fee charged when a DuckDuckGo SERP run starts. | $0.005 |

| Event | What is charged | Free / no discount | Starter / Bronze | Scale / Silver | Business / Gold | Custom / Platinum | Custom / Diamond |
| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: |
| `result` | Per organic DuckDuckGo search result saved to the dataset. | $0.10772 / 1,000 | $0.09367 / 1,000 | $0.07306 / 1,000 | $0.0562 / 1,000 | $0.03747 / 1,000 | $0.02623 / 1,000 |

Apify may also charge platform usage for compute, storage, proxies, or data transfer outside this Actor pricing. Check the Actor run and the Apify Pricing tab for the exact cost shown to your account.

### How to use DuckDuckGo Search Results Scraper

1. Open the actor on Apify.
2. Enter one or more search queries.
3. Choose the maximum number of results per query.
4. Optionally choose a DuckDuckGo region code such as `us-en` or `uk-en`.
5. Choose a Safe Search setting.
6. Run the actor.
7. Download results as CSV, JSON, Excel, or access them through the API.

### Input settings

| Field | Description |
| --- | --- |
| `queries` | List of DuckDuckGo search terms to scrape. |
| `query` | Optional single search query for quick API calls. |
| `maxResults` | Maximum organic results to save per query. |
| `region` | DuckDuckGo localization code such as `us-en`, `uk-en`, `de-de`, or `fr-fr`. |
| `safeSearch` | Safe-search mode: `strict`, `moderate`, or `off`. |
| `proxyConfiguration` | Apify Proxy settings; enable proxy if direct requests are rate-limited. |

#### Queries

Use `queries` for a list of search terms.

#### Input example

```json
{
  "queries": ["apify web scraping", "privacy search engine"],
  "maxResults": 10
}
```

#### Single query

Use `query` for quick API calls with one keyword.

#### Max results

`maxResults` controls how many organic rows are saved for each query.

The default is intentionally low for a cheap first run.

#### Region

`region` maps to DuckDuckGo localization codes such as `us-en`, `uk-en`, `de-de`, or `fr-fr`.

#### Safe Search

`safeSearch` supports `strict`, `moderate`, and `off`.

#### Proxy configuration

DuckDuckGo can rate-limit shared IPs.

If direct requests return no results, enable Apify Proxy in the `proxyConfiguration` input.

### Output example

```json
{
  "query": "apify web scraping",
  "rank": 1,
  "title": "Apify: Full-stack web scraping and data extraction platform",
  "url": "https://apify.com/",
  "displayUrl": "apify.com",
  "snippet": "Apify is a web scraping and automation platform...",
  "redirectUrl": "https://duckduckgo.com/l/?uddg=...",
  "region": "us-en",
  "page": 1,
  "scrapedAt": "2026-07-05T08:00:00.000Z"
}
```

### Tips for better SERP monitoring

Use consistent region settings across recurring runs.

Keep `maxResults` small for frequent rank checks.

Use separate runs for different markets if you need market-by-market reporting.

Store datasets or export them to your BI tool for historical tracking.

### Integrations

Send results to Google Sheets for rank dashboards.

Trigger the actor from Make or Zapier for weekly monitoring.

Use the Apify API to enrich internal SEO tools.

Export datasets to BigQuery, Snowflake, or your data warehouse.

Combine this actor with other `fetch_cat` search and content scrapers for broader visibility reports.

### API examples

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/duckduckgo-search-results-scraper').call({
  queries: ['apify web scraping'],
  maxResults: 10,
  region: 'us-en',
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/duckduckgo-search-results-scraper').call(run_input={
    'queries': ['apify web scraping'],
    'maxResults': 10,
    'region': 'us-en',
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~duckduckgo-search-results-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"queries":["apify web scraping"],"maxResults":10,"region":"us-en"}'
```

### MCP integration

Use the actor from MCP-compatible tools through Apify MCP.

MCP URL:

```text
https://mcp.apify.com/?tools=fetch_cat/duckduckgo-search-results-scraper
```

Claude Code setup example:

```bash
claude mcp add apify https://mcp.apify.com/?tools=fetch_cat/duckduckgo-search-results-scraper
```

Claude Desktop JSON config example:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/duckduckgo-search-results-scraper"
    }
  }
}
```

Example prompts showing MCP usage:

```text
Run fetch_cat/duckduckgo-search-results-scraper for "privacy search engine" and summarize the top 10 domains.
```

```text
Use the DuckDuckGo scraper to collect 10 results for "SEO rank tracking" in us-en and return a table with rank, title, and URL.
```

Claude Desktop users can add the Apify MCP server and call this actor as a tool.

Claude Code users can use it for automated SERP checks inside research or SEO workflows.

### Ready-to-run examples

Open the actor's public Examples tab for saved input recipes you can copy and run:

- [DuckDuckGo keyword monitoring example](https://apify.com/fetch_cat/duckduckgo-search-results-scraper/examples/duckduckgo-keyword-monitoring)

### Example use cases

Monitor keyword rankings on DuckDuckGo.

Collect top competitor pages for a topic.

Build privacy-search SERP snapshots.

Compare result snippets across markets.

Feed search result URLs into a crawler or content audit.

### Limits and reliability

DuckDuckGo may rate-limit high-volume or repeated requests.

Use conservative query batches for recurring jobs.

Enable Apify Proxy if you see anomaly pages or empty results.

The actor focuses on organic web results in v1.

Ads, knowledge panels, news, images, and videos may be added later as separate structured fields or datasets.

### FAQ

#### Can I run multiple keywords at once?

Yes. Add several values to `queries`; `maxResults` applies to each query independently.

#### Does the actor scrape ads or news results?

The first version focuses on organic web results. Ads, news, images, and videos are possible future result types.

### Troubleshooting

#### Why did my run return no items?

The query may have no organic results, or DuckDuckGo may have returned an anomaly page for the current IP.

Try a common test query, reduce volume, or enable Apify Proxy.

#### Why are results different from my browser?

Search results can vary by region, safe-search setting, time, personalization context, and IP location.

Set `region` consistently when comparing runs.

### Legality

#### Is it legal to scrape DuckDuckGo search results?

This actor extracts publicly visible search result metadata.

You are responsible for using the data lawfully, respecting DuckDuckGo terms, and complying with privacy, copyright, and database laws that apply to your use case.

Do not use scraped data for spam, abuse, or prohibited profiling.

### Related actors

- [Bing Search Results Scraper](https://apify.com/fetch_cat/bing-search-results-scraper)
- [Google Trending Searches Scraper](https://apify.com/fetch_cat/google-trending-searches-scraper)
- [Google Patents Search Scraper](https://apify.com/fetch_cat/google-patents-search-scraper)
- [YouTube Search Results Scraper](https://apify.com/fetch_cat/youtube-search-results-scraper)

### Support

If you need a new field, a different result type, or help with recurring SERP monitoring, open an issue on the actor page.

For the fastest support, include:

- The Apify run ID or run URL
- The input JSON you used
- The expected output or fields you wanted
- The actual output you received
- A reproducible public URL or keyword example when possible

### Privacy and data handling

This Actor only requests the permissions needed to run the input you provide. It uses your input (such as URLs, search terms, identifiers, filters, and limits) only to fetch the requested public data from the relevant source site or API for this Actor, then writes results to your Apify dataset/key-value store.

Data may pass through Apify platform services and Apify Proxy during the run, and requests are sent only to the target site or public data provider required for this Actor's results. FetchCat does not send your inputs or outputs to advertising networks, data brokers, or model-training services, and does not retain run data outside Apify storage after the run except when you explicitly share run details for transient support debugging.

You are responsible for using this Actor lawfully, respecting the target site's terms, and avoiding unnecessary personal or sensitive data in inputs. Review the output before storing, sharing, or combining it with other data.

# Actor input Schema

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

DuckDuckGo search terms to scrape. Each query receives up to Max results.

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

Optional single query. Use this for quick API calls; it is combined with Queries above.

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

Maximum number of organic search results to save for each query.

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

Optional DuckDuckGo region code, for example us-en, uk-en, de-de, fr-fr, or es-es.

## `safeSearch` (type: `string`):

DuckDuckGo safe-search setting to apply to the search request.

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

DuckDuckGo can rate-limit shared IPs. Enable Apify Proxy if direct requests return anomaly pages.

## Actor input object example

```json
{
  "queries": [
    "apify web scraping",
    "privacy search engine"
  ],
  "maxResults": 10,
  "region": "us-en",
  "safeSearch": "moderate",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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": [
        "apify web scraping",
        "privacy search engine"
    ],
    "region": "us-en",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/duckduckgo-search-results-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": [
        "apify web scraping",
        "privacy search engine",
    ],
    "region": "us-en",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/duckduckgo-search-results-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": [
    "apify web scraping",
    "privacy search engine"
  ],
  "region": "us-en",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call fetch_cat/duckduckgo-search-results-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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