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

Pull DuckDuckGo organic search results with rank, title, URL, snippet, displayed URL, and favicon. Filter by region, time range, and safe-search. Export clean JSON, CSV, or Excel for privacy-respecting SEO research, competitor discovery, and SERP monitoring with no rate-limit headaches.

- **URL**: https://apify.com/parseforge/duckduckgo-search-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Marketing, Business, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.25 / 1,000 items

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🦆 DuckDuckGo Search Scraper

> 🚀 **Pull DuckDuckGo organic search results with privacy-first defaults.** Region, time-range, and safe-search filters. Pagination past 100 results per query. No tracking, no API key.

> 🕒 **Last updated:** 2026-05-01 · **📊 7 fields** per result · **🌍 50+ regions** · **🔄 paginated to 100+** · **🦆 100M+ daily searches**

The **DuckDuckGo Search Scraper** queries the public DuckDuckGo HTML endpoint and returns the ranked organic results page with title, source URL, displayed URL, and snippet. The Actor decodes the DDG redirect wrapper so you get clean destination URLs and paginates through the offset parameter to reach well past 100 organic listings per query.

DuckDuckGo serves more than 100 million searches per day and is the default privacy alternative for journalists, security teams, and lawyers. Because DDG blends results from a different signal mix than Google or Bing, certain listings surface here that competitors bury, especially in newer or niche topics. This Actor exposes that data cleanly with region and time-range filters.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Privacy researchers, SEO teams, journalists, security analysts, OSINT teams | Alternative SERP tracking, regional comparison, niche topic discovery, OSINT lookups |

---

### 📋 What the DuckDuckGo Search Scraper does

Five filtering workflows in a single run:

- 🔍 **Multi-query batches.** Submit a list of queries, the Actor runs each as a separate search.
- 🌍 **Region filter.** DDG's `kl` parameter routes the query through that regional index.
- 📅 **Time-range filter.** Restrict to last day, week, month, or year using DDG's `df` parameter.
- 🛡️ **Safe-search filter.** Strict, moderate, or off via the `kp` parameter.
- 🔄 **Pagination.** Walks past the first 30 results using offset increments and rotates proxies between pages.

Each row reports the originating query, rank position, title, decoded source URL, displayed URL, and the snippet text DDG renders under the title.

> 💡 **Why it matters:** DuckDuckGo treats every visitor identically because it does not personalize on cookies or IP. That is exactly what SEO researchers want when they need a non-personalized rank snapshot. Privacy-conscious audiences also use DDG as their default, so a brand's DDG visibility matters in healthcare, legal, and finance.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Results to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td><code>queries</code></td><td>array of strings</td><td><code>["apify scraper"]</code></td><td>One or more search queries.</td></tr>
<tr><td><code>region</code></td><td>string</td><td><code>"us-en"</code></td><td>DDG region code like <code>us-en</code>, <code>de-de</code>, <code>fr-fr</code>.</td></tr>
<tr><td><code>timeRange</code></td><td>string</td><td>empty</td><td><code>d</code>, <code>w</code>, <code>m</code>, or <code>y</code> for last day, week, month, year.</td></tr>
<tr><td><code>safeSearch</code></td><td>string</td><td><code>"moderate"</code></td><td><code>strict</code>, <code>moderate</code>, or <code>off</code>.</td></tr>
</tbody>
</table>

**Example: 100 organic results for "web scraping" in the US.**

```json
{
    "maxItems": 100,
    "queries": ["web scraping"],
    "region": "us-en"
}
````

**Example: this-week results for two queries in Germany.**

```json
{
    "maxItems": 60,
    "queries": ["KI Agenten", "Web Scraping API"],
    "region": "de-de",
    "timeRange": "w"
}
```

> ⚠️ **Good to Know:** the Actor decodes DDG's `/l/?uddg=...` redirect wrapper so the `url` field contains the actual destination domain. Pagination beyond 30 results uses POST with offset; the Actor handles this automatically with proxy rotation between pages.

***

### 📊 Output

Each result row contains **7 fields**. Download as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🔍 `query` | string | `"web scraping"` |
| 🏆 `rank` | integer | `1` |
| 📰 `title` | string | `"What is Web Scraping and How to Use It? - GeeksforGeeks"` |
| 🔗 `url` | string | `"https://www.geeksforgeeks.org/blogs/..."` |
| 🌐 `displayedUrl` | string | `"www.geeksforgeeks.org/blogs/..."` |
| 📝 `snippet` | string | `"Web scraping is an automated method to extract..."` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-01T01:15:39.046Z"` |

#### 📦 Sample records

<details>
<summary><strong>📚 Educational source: GeeksforGeeks</strong></summary>

```json
{
    "query": "web scraping",
    "rank": 1,
    "title": "What is Web Scraping and How to Use It? - GeeksforGeeks",
    "url": "https://www.geeksforgeeks.org/blogs/what-is-web-scraping-and-how-to-use-it/",
    "displayedUrl": "www.geeksforgeeks.org/blogs/what-is-web-scraping-and-how-to-use-it/",
    "snippet": "Web scraping is an automated method to extract large amounts of data from websites. This data, usually in HTML format, is converted into structured formats like spreadsheets or databases...",
    "scrapedAt": "2026-05-01T01:15:39.046Z"
}
```

</details>

<details>
<summary><strong>📖 Wikipedia article ranking high on a generic term</strong></summary>

```json
{
    "query": "web scraping",
    "rank": 2,
    "title": "Web scraping - Wikipedia",
    "url": "https://en.wikipedia.org/wiki/Web_scraping",
    "displayedUrl": "en.wikipedia.org/wiki/Web_scraping",
    "snippet": "Web scraping is data extraction from websites using automated processes. Learn about its origins, methods, applications, and challenges from this comprehensive Wikipedia article.",
    "scrapedAt": "2026-05-01T01:15:39.047Z"
}
```

</details>

<details>
<summary><strong>🌐 Result from a multi-query run with rank reset per query</strong></summary>

```json
{
    "query": "apify scraper",
    "rank": 1,
    "title": "Apify Store",
    "url": "https://apify.com/store",
    "displayedUrl": "apify.com/store",
    "snippet": "Build, deploy, and monetize web scrapers and AI agents on Apify",
    "scrapedAt": "2026-05-01T01:15:42.110Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🔒 | **Privacy-first source.** DDG does not personalize on cookies or IP, so rankings are stable across users. |
| 🔄 | **Past page 1.** Offset pagination plus proxy rotation reaches 100+ organic results per query. |
| 🌍 | **50+ regional indexes.** Aligns with the audience's actual regional search defaults. |
| 📅 | **Time-range slice.** Day, week, month, year windows for fresh content tracking. |
| 📦 | **Multi-query batching.** Submit dozens of queries per run. |
| 🔗 | **Decoded URLs.** No DDG redirect wrappers in the output. |
| 🛡️ | **Anti-bot handled.** Proxy rotation per page keeps single-IP throttling at bay. |

> 📊 In a single 31-second run the Actor returned 100 organic results for the query "web scraping".

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| Direct browser scraping | Free | Hits captchas | Live | Manual | Engineer hours |
| Paid SERP APIs | $$$ subscription | Full | Live | Built-in | Account setup |
| Generic search-data brokers | $$ subscription | Aggregated | Daily | Limited | Account setup |
| **⭐ DuckDuckGo Search Scraper** *(this Actor)* | Pay-per-event | Past page 1 | Live | Region, time, safe-search | None |

Same data the DDG SERP serves, exposed as clean records with redirect wrappers decoded.

***

### 🚀 How to use

1. 🆓 **Create a free Apify account.** [Sign up here](https://console.apify.com/sign-up?fpr=vmoqkp) and get $5 in free credit.
2. 🔍 **Open the Actor.** Search for "DuckDuckGo Search" in the Apify Store.
3. ⚙️ **Set queries and filters.** Add queries, pick region and time range.
4. ▶️ **Click Start.** A 100-result run typically completes in 25 to 45 seconds.
5. 📥 **Download.** Export as CSV, Excel, JSON, or XML.

> ⏱️ Total time from sign-up to first dataset: under five minutes.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%">

#### 📈 SEO & content

- Capture a non-personalized rank snapshot
- Track DDG visibility for privacy-sensitive audiences
- Monitor regional rank differences across 50+ markets
- Audit how DDG resurfaces older evergreen content

</td>
<td width="50%">

#### 🛡️ Brand & OSINT

- Detect impersonation pages on a non-Google index
- Cross-reference Google rank with DDG rank to spot anomalies
- Run OSINT lookups without leaking searcher identity
- Audit reputation across privacy-respecting search

</td>
</tr>
<tr>
<td width="50%">

#### ⚖️ Legal & finance

- Reproducible SERP snapshots for case research
- Track how DDG presents regulated topics
- Build evidence-grade rank reports
- Run unbiased rank checks for internal audits

</td>
<td width="50%">

#### 📰 Journalism

- Compare regional SERPs for the same story
- Track time-range search shifts during news cycles
- Cite DDG with stable URLs and timestamps
- Monitor how privacy-engine surfaces sources

</td>
</tr>
</table>

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Empirical datasets for papers, thesis work, and coursework
- Longitudinal studies tracking changes across snapshots
- Reproducible research with cited, versioned data pulls
- Classroom exercises on data analysis and ethical scraping

</td>
<td width="50%">

#### 🎨 Personal and creative

- Side projects, portfolio demos, and indie app launches
- Data visualizations, dashboards, and infographics
- Content research for bloggers, YouTubers, and podcasters
- Hobbyist collections and personal trackers

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Transparency reporting and accountability projects
- Advocacy campaigns backed by public-interest data
- Community-run databases for local issues
- Investigative journalism on public records

</td>
<td width="50%">

#### 🧪 Experimentation

- Prototype AI and machine-learning pipelines with real data
- Validate product-market hypotheses before engineering spend
- Train small domain-specific models on niche corpora
- Test dashboard concepts with live input

</td>
</tr>
</table>

***

### 🔌 Automating DuckDuckGo Search Scraper

Run this Actor on a schedule, from your codebase, or inside another tool:

- **Node.js** SDK: see [Apify JavaScript client](https://docs.apify.com/api/client/js/) for programmatic runs.
- **Python** SDK: see [Apify Python client](https://docs.apify.com/api/client/python/) for the same flow in Python.
- **HTTP API**: see [Apify API docs](https://docs.apify.com/api/v2) for raw REST integration.

Schedule daily or weekly runs from the Apify Console. Pipe results into Google Sheets, S3, BigQuery, or your own webhook with the built-in [integrations](https://docs.apify.com/platform/integrations).

***

### ❓ Frequently Asked Questions

<details>
<summary><strong>🔗 Does the URL field contain DDG redirect wrappers?</strong></summary>

No. The Actor decodes the `/l/?uddg=...` wrapper before saving each row, so `url` is the real destination URL. The `displayedUrl` field shows the version DDG renders under the title.

</details>

<details>
<summary><strong>🌍 Which regions are supported?</strong></summary>

DDG uses 50+ region codes in the `us-en`, `de-de`, `fr-fr` format. Pass any valid code as a string. The DDG documentation lists all valid region codes.

</details>

<details>
<summary><strong>📅 What does the time-range filter accept?</strong></summary>

Single-letter codes: `d` for last day, `w` for last week, `m` for last month, `y` for last year. Empty returns all-time results.

</details>

<details>
<summary><strong>📦 How many results can I pull per query?</strong></summary>

Up to 100 organic results per query in a typical run. DDG's offset pagination caps at roughly 100 results before throttling.

</details>

<details>
<summary><strong>🔄 Can I run multiple queries in one run?</strong></summary>

Yes. The `queries` input is a string array. Rank position resets per query in the dataset.

</details>

<details>
<summary><strong>🛡️ Why does the Actor rotate proxies?</strong></summary>

DDG's HTML endpoint throttles repeat requests from the same IP. Apify residential proxies route each page through a fresh consumer IP so the SERP HTML stays clean.

</details>

<details>
<summary><strong>🤖 Are images, videos, and ads included?</strong></summary>

No. This Actor focuses on the organic web results list. Image, video, and instant-answer blocks render under different selectors and are out of scope.

</details>

<details>
<summary><strong>💼 Can I use this for commercial work?</strong></summary>

Yes. The Actor reads only what DDG publicly serves to any browser. Always honor each downstream site's terms of service when republishing snippets.

</details>

<details>
<summary><strong>💳 Do I need a paid Apify plan?</strong></summary>

The free plan returns up to 10 results per run. Paid plans return up to 1,000,000. Pay-per-event pricing means you only pay for the results returned.

</details>

<details>
<summary><strong>⚠️ What if a run returns thin or no results?</strong></summary>

The Actor retries with proxy rotation on thin responses. If a query genuinely has fewer results, that reflects the SERP. [Open a contact form](https://tally.so/r/BzdKgA) and include the run URL if you suspect a bug.

</details>

<details>
<summary><strong>🔁 How fresh is the data?</strong></summary>

Live. Each run hits DDG at run time, so you get whatever the SERP shows right now.

</details>

<details>
<summary><strong>⚖️ Is scraping DuckDuckGo legal?</strong></summary>

Reading public SERP HTML is widely accepted as fair use for SEO research. The Actor does not bypass paywalls, does not sign in, and respects per-page proxy rotation to avoid undue load.

</details>

***

### 🔌 Integrate with any app

- [**Make**](https://apify.com/integrations/make) - drop run results into 1,800+ apps.
- [**Zapier**](https://apify.com/integrations/zapier) - trigger automations off completed runs.
- [**Slack**](https://apify.com/integrations/slack) - post run summaries to a channel.
- [**Google Sheets**](https://apify.com/integrations/google-sheets) - sync each run into a spreadsheet.
- [**Webhooks**](https://docs.apify.com/platform/integrations/webhooks) - notify your own services on run finish.
- [**Airbyte**](https://apify.com/integrations/airbyte) - load runs into Snowflake, BigQuery, or Postgres.

***

### 🔗 Recommended Actors

- [**🅱️ Bing Search Scraper**](https://apify.com/parseforge/bing-search-scraper) - cross-reference rank shifts on the second-largest Western SERP.
- [**📚 Wikipedia Pageviews Scraper**](https://apify.com/parseforge/wikipedia-pageviews-scraper) - pair rank with public-interest spikes.
- [**🕰️ Wayback Machine CDX Scraper**](https://apify.com/parseforge/wayback-cdx-scraper) - audit historical versions of pages that rank.
- [**🐙 GitHub Trending Repos Scraper**](https://apify.com/parseforge/github-trending-scraper) - capture the developer-attention layer.
- [**📰 Substack Publication Scraper**](https://apify.com/parseforge/substack-publication-scraper) - track newsletter content that ranks for your queries.

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more pre-built scrapers and data tools.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) and we'll route the question to the right person.

***

> DuckDuckGo is a registered trademark of DuckDuckGo, Inc. This Actor is not affiliated with or endorsed by DuckDuckGo. It reads only publicly visible SERP HTML the same way a normal browser does.

# Actor input Schema

## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000.

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

Keywords to search on DuckDuckGo. Each query produces multiple result rows.

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

DuckDuckGo region code. Examples: `us-en` (United States, English), `uk-en`, `de-de`, `es-es`, `mx-es`, `br-pt`, `wt-wt` (no region).

## `timeRange` (type: `string`):

Restrict to recent results: `d` (past day), `w` (past week), `m` (past month), `y` (past year). Empty = any time.

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

DuckDuckGo SafeSearch level: `off`, `moderate`, `strict`.

## Actor input object example

```json
{
  "maxItems": 10,
  "queries": [
    "apify scraper"
  ],
  "region": "us-en",
  "timeRange": "",
  "safeSearch": "moderate"
}
```

# 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 = {
    "maxItems": 10,
    "queries": [
        "apify scraper"
    ],
    "region": "us-en",
    "timeRange": "",
    "safeSearch": "moderate"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/duckduckgo-search-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 = {
    "maxItems": 10,
    "queries": ["apify scraper"],
    "region": "us-en",
    "timeRange": "",
    "safeSearch": "moderate",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/duckduckgo-search-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 '{
  "maxItems": 10,
  "queries": [
    "apify scraper"
  ],
  "region": "us-en",
  "timeRange": "",
  "safeSearch": "moderate"
}' |
apify call parseforge/duckduckgo-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "DuckDuckGo Search Results Scraper",
        "description": "Pull DuckDuckGo organic search results with rank, title, URL, snippet, displayed URL, and favicon. Filter by region, time range, and safe-search. Export clean JSON, CSV, or Excel for privacy-respecting SEO research, competitor discovery, and SERP monitoring with no rate-limit headaches.",
        "version": "1.0",
        "x-build-id": "Cw0vYN8505V6vdhVY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~duckduckgo-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-duckduckgo-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~duckduckgo-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-duckduckgo-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~duckduckgo-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-duckduckgo-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000."
                    },
                    "queries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Keywords to search on DuckDuckGo. Each query produces multiple result rows.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "region": {
                        "title": "Region",
                        "enum": [
                            "wt-wt",
                            "us-en",
                            "uk-en",
                            "ca-en",
                            "au-en",
                            "nz-en",
                            "de-de",
                            "es-es",
                            "fr-fr",
                            "it-it",
                            "nl-nl",
                            "pl-pl",
                            "se-sv",
                            "no-no",
                            "fi-fi",
                            "dk-da",
                            "cz-cs",
                            "sk-sk",
                            "ro-ro",
                            "hu-hu",
                            "ru-ru",
                            "tr-tr",
                            "gr-el",
                            "mx-es",
                            "br-pt",
                            "ar-es",
                            "cl-es",
                            "co-es",
                            "jp-jp",
                            "kr-kr",
                            "cn-zh",
                            "tw-tzh",
                            "hk-tzh",
                            "in-en",
                            "id-id",
                            "vn-vi",
                            "th-th",
                            "my-en",
                            "sg-en",
                            "ph-en",
                            "ae-ar",
                            "sa-ar",
                            "il-he",
                            "za-en"
                        ],
                        "type": "string",
                        "description": "DuckDuckGo region code. Examples: `us-en` (United States, English), `uk-en`, `de-de`, `es-es`, `mx-es`, `br-pt`, `wt-wt` (no region).",
                        "default": "us-en"
                    },
                    "timeRange": {
                        "title": "Time range",
                        "enum": [
                            "",
                            "d",
                            "w",
                            "m",
                            "y"
                        ],
                        "type": "string",
                        "description": "Restrict to recent results: `d` (past day), `w` (past week), `m` (past month), `y` (past year). Empty = any time.",
                        "default": ""
                    },
                    "safeSearch": {
                        "title": "SafeSearch",
                        "enum": [
                            "off",
                            "moderate",
                            "strict"
                        ],
                        "type": "string",
                        "description": "DuckDuckGo SafeSearch level: `off`, `moderate`, `strict`.",
                        "default": "moderate"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
