# DuckDuckGo Search Scraper — Organic SERP API (`datascraperes/duckduckgo-search-results-scraper`) Actor
Get clean, paginated DuckDuckGo organic search results with rank, title, URL, domain, and snippet. Fast HTTP, 68 regions, and pay-per-result pricing.
- **URL**: https://apify.com/datascraperes/duckduckgo-search-results-scraper.md
- **Developed by:** [DataScraperES](https://apify.com/datascraperes) (community)
- **Categories:** SEO tools, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 7.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
$0.60 / 1,000 organic 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.
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/docs.md):
```bash
npm install apify-client
```
In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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
Collect live, paginated **organic web search results from [DuckDuckGo](https://duckduckgo.com/)** without setting up a browser, proxy, or scraping infrastructure. Enter one or more search queries, select a region and Safe Search level, and receive structured results ready for SEO analysis, research, spreadsheets, databases, or automation.
[Run DuckDuckGo Search Scraper on Apify](https://apify.com/datascraperes/duckduckgo-search-results-scraper).
Each result includes its organic position, title, destination URL, domain, displayed URL, snippet, query, region, page number, and retrieval time. The Actor extracts organic web results only: advertisements, images, news, videos, and shopping results are not included.
### Why use this DuckDuckGo Search Scraper?
- **Paginated organic results:** collect up to 100 results and 10 pages per query.
- **Bulk search:** process up to 1,000 queries in one run.
- **Regional search:** choose from 68 DuckDuckGo regional markets.
- **Safe Search control:** use Strict, Moderate, or Off filtering.
- **Clean destination URLs:** DuckDuckGo redirect links are decoded before delivery.
- **Consistent ranking fields:** receive both page-level and overall organic positions.
- **Duplicate protection:** repeated queries and duplicate destination URLs are removed automatically.
- **Production-friendly runs:** automatic retries and per-query isolation prevent one failed query from stopping an entire batch.
- **Simple pay-per-result pricing:** pay only for organic results delivered to the dataset.
- **No user proxy setup:** open the Actor, provide queries, and start the run.
### Common use cases
- Track organic rankings for keywords across countries and languages.
- Discover websites and domains ranking for a topic.
- Build competitor, keyword, and content-research datasets.
- Collect search results for AI retrieval, classification, or enrichment workflows.
- Monitor changes in DuckDuckGo search results with scheduled runs.
- Export search data to JSON, CSV, Excel, or XML.
- Send results to Google Sheets, Make, Zapier, webhooks, or your own application.
### How to scrape DuckDuckGo search results
No coding is required.
1. Open the Actor's **Input** tab.
2. Add one search query per line under **Search queries**.
3. Choose the maximum number of results and pages for each query.
4. Select the desired region and Safe Search setting.
5. Click **Start**.
6. Open the **Dataset** or **Output** tab to preview, filter, and download the results.
For a first test, use one query with the defaults: 10 results, one page, no specific region, and Moderate Safe Search.
### Input example
This example requests up to 30 organic results for each query, follows up to three result pages, and localizes the search to the United States:
```json
{
"queries": [
"best python web scraping libraries",
"apify actor tutorial"
],
"maxResultsPerQuery": 30,
"maxPagesPerQuery": 3,
"region": "us-en",
"safeSearch": "Moderate"
}
````
### Input options
| Field | Type | Default | Accepted values | What it does |
| --- | --- | --- | --- | --- |
| `queries` | string array | Required | 1–1,000 queries; maximum 500 characters each | Search terms to send to DuckDuckGo. Add one query per line in the Input UI. Blank values and case-insensitive duplicates are removed. |
| `maxResultsPerQuery` | integer | `10` | `1`–`100` | Maximum number of unique organic results delivered for each query. |
| `maxPagesPerQuery` | integer | `1` | `1`–`10` | Maximum number of DuckDuckGo pages the Actor may request for each query. |
| `region` | string | `wt-wt` | One of the supported region codes | Localizes the result set to a country or language market. `wt-wt` does not request a specific region. |
| `safeSearch` | string | `Moderate` | `Strict`, `Moderate`, `Off` | Controls DuckDuckGo's explicit-content filtering. Values are case-sensitive when using JSON or the API. |
#### Results and pages work together
The Actor stops a query as soon as one of these conditions is reached:
- `maxResultsPerQuery` unique results have been collected;
- `maxPagesPerQuery` pages have been fetched;
- DuckDuckGo returns no results or no new unique results;
- the run reaches the maximum charge selected by the user;
- repeated request attempts cannot complete the query.
DuckDuckGo can return a variable number of organic results per page. If you request 50 results but allow only one page, the Actor may deliver fewer than 50. Increase `maxPagesPerQuery` when requesting larger result sets. A practical starting point is one page for 10 results, three pages for 30 results, and up to 10 pages for larger collections.
#### Region codes
The Input UI displays friendly region names. When calling the Actor through JSON or the API, send the corresponding code.
| Market | Code |
| --- | --- |
| No specific region | `wt-wt` |
| United States — English | `us-en` |
| United States — Spanish | `ue-es` |
| United Kingdom | `uk-en` |
| Spain | `es-es` |
| Latin America | `xl-es` |
| Mexico | `mx-es` |
| Canada — English | `ca-en` |
| Canada — French | `ca-fr` |
| Brazil | `br-pt` |
| France | `fr-fr` |
| Germany | `de-de` |
Show all 68 supported region codes
**Default**
- `wt-wt` — No specific region
**Americas**
- `us-en` — United States (English)
- `ue-es` — United States (Spanish)
- `xl-es` — Latin America
- `mx-es` — Mexico
- `ar-es` — Argentina
- `cl-es` — Chile
- `co-es` — Colombia
- `pe-es` — Peru
- `ve-es` — Venezuela
- `ca-en` — Canada (English)
- `ca-fr` — Canada (French)
- `br-pt` — Brazil
**Europe**
- `uk-en` — United Kingdom
- `es-es` — Spain
- `pt-pt` — Portugal
- `fr-fr` — France
- `de-de` — Germany
- `it-it` — Italy
- `nl-nl` — Netherlands
- `be-fr` — Belgium (French)
- `be-nl` — Belgium (Dutch)
- `ch-de` — Switzerland (German)
- `ch-fr` — Switzerland (French)
- `ch-it` — Switzerland (Italian)
- `at-de` — Austria
- `ie-en` — Ireland
- `tr-tr` — Turkey
- `pl-pl` — Poland
- `cz-cs` — Czech Republic
- `sk-sk` — Slovakia
- `ro-ro` — Romania
- `hu-hu` — Hungary
- `gr-el` — Greece
- `bg-bg` — Bulgaria
- `hr-hr` — Croatia
- `sl-sl` — Slovenia
- `dk-da` — Denmark
- `fi-fi` — Finland
- `no-no` — Norway
- `se-sv` — Sweden
- `ee-et` — Estonia
- `lv-lv` — Latvia
- `lt-lt` — Lithuania
- `ua-uk` — Ukraine
- `ru-ru` — Russia
- `ct-ca` — Catalan
**Asia and Pacific**
- `au-en` — Australia
- `nz-en` — New Zealand
- `in-en` — India
- `jp-jp` — Japan
- `kr-kr` — South Korea
- `cn-zh` — China
- `hk-tzh` — Hong Kong
- `tw-tzh` — Taiwan
- `sg-en` — Singapore
- `my-ms` — Malaysia (Malay)
- `my-en` — Malaysia (English)
- `id-id` — Indonesia (Indonesian)
- `id-en` — Indonesia (English)
- `ph-en` — Philippines (English)
- `ph-tl` — Philippines (Tagalog)
- `th-th` — Thailand
- `vn-vi` — Vietnam
**Middle East and Africa**
- `il-he` — Israel
- `za-en` — South Africa
- `xa-ar` — Arabia (Arabic)
- `xa-en` — Arabia (English)
#### Safe Search values
| Value | Recommended use |
| --- | --- |
| `Strict` | Apply the strongest explicit-content filtering. |
| `Moderate` | Balanced filtering and the default for most searches. |
| `Off` | Request results without Safe Search filtering. |
### Output example
The default dataset contains one item for every delivered organic result. A typical item looks like this:
```json
{
"type": "organicResult",
"resultId": "b7e765afe3c62166bb1f69543163e312",
"query": "apify actor tutorial",
"queryId": "efaa5d1aa8e60b8681af52ff",
"region": "us-en",
"safeSearch": "Moderate",
"page": 1,
"pagePosition": 1,
"position": 1,
"title": "Actors | Platform | Apify Documentation",
"url": "https://docs.apify.com/platform/actors",
"domain": "docs.apify.com",
"displayUrl": "docs.apify.com/platform/actors",
"description": "Learn how to build and run Apify Actors.",
"pagesFetched": 1,
"organicResultsFound": 10,
"paginationStoppedReason": "max_results_reached",
"fetchedAt": "2026-07-13T10:30:00+00:00"
}
```
### Output fields
| Field | Type | Meaning |
| --- | --- | --- |
| `type` | string | Always `organicResult`. |
| `resultId` | string | Stable identifier generated from the query settings and destination URL. Useful for deduplication. |
| `query` | string | Normalized search query that produced the result. |
| `queryId` | string | Stable identifier generated from the query, region, and Safe Search setting. |
| `region` | string | DuckDuckGo regional market used for the query. |
| `safeSearch` | string | Safe Search setting used for the query. |
| `page` | integer | DuckDuckGo result page where the item appeared, starting at 1. |
| `pagePosition` | integer | Organic position within that page, starting at 1. |
| `position` | integer | Overall organic position across all fetched pages for the query, starting at 1. |
| `title` | string | Organic result title. |
| `url` | string | Decoded destination URL. |
| `domain` | string or null | Hostname extracted from the destination URL. |
| `displayUrl` | string or null | URL text displayed by DuckDuckGo. |
| `description` | string or null | Search-result snippet when available. |
| `pagesFetched` | integer | Total number of pages successfully fetched for this query. |
| `organicResultsFound` | integer | Number of unique organic results found for this query before any final budget truncation. |
| `paginationStoppedReason` | string | Reason the Actor stopped following result pages. |
| `fetchedAt` | string | UTC timestamp recorded when the query finished. |
`position` represents the order of the organic results returned by this run. Advertisements are excluded and do not consume ranking positions in the dataset.
### Downloading and integrating results
Open the run's **Dataset** tab to preview the results or export them in formats such as JSON, CSV, Excel, and XML. You can also use Apify integrations to send data to external tools, trigger a webhook when a run finishes, or save the input as a Task and schedule recurring searches.
The **Output** tab provides direct links to:
- **Organic search results:** the default dataset containing billable result rows.
- **Run summary:** totals for requested, completed, empty, partial, failed, and budget-skipped queries, plus pages and delivered results.
- **Query diagnostics:** details for queries that were empty, partial, failed, or skipped because of the run budget. Successful queries are represented directly by their dataset results.
### Run through the Apify API
The Actor's **API** tab provides ready-to-use examples containing the correct Actor ID for your account. Never expose your Apify API token in public code.
#### Python client
Install the official client:
```bash
pip install apify-client
```
Run the Actor and iterate over its dataset:
```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_API_TOKEN")
run_input = {
"queries": ["best python web scraping libraries", "apify actor tutorial"],
"maxResultsPerQuery": 30,
"maxPagesPerQuery": 3,
"region": "us-en",
"safeSearch": "Moderate"
}
run = client.actor("datascraperes/duckduckgo-search-results-scraper").call(
run_input=run_input
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
print(item["position"], item["title"], item["url"])
```
The Actor can also be addressed by its immutable ID: `WMQyI6FacMcnQLdeh`.
#### Synchronous HTTP request
For small runs, you can start the Actor and receive the dataset items in one request:
```bash
curl -X POST \
"https://api.apify.com/v2/acts/datascraperes~duckduckgo-search-results-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"queries": ["apify actor tutorial"],
"maxResultsPerQuery": 10,
"maxPagesPerQuery": 1,
"region": "us-en",
"safeSearch": "Moderate"
}'
```
For large query lists, use the asynchronous Actor run endpoint or the Python client so the caller does not need to keep one HTTP request open.
### Pricing
The Actor uses pay-per-event pricing. One `organic-result` event costs **$0.00015** and corresponds to one organic result successfully delivered to the default dataset.
| Delivered results | Actor price |
| ---: | ---: |
| 10 | $0.0015 |
| 100 | $0.015 |
| 1,000 | $0.15 |
| 10,000 | $1.50 |
There is no Actor start fee, and platform usage is included in the result price. Empty queries, failed requests, advertisements, diagnostic records, and results that cannot be delivered because of the user's maximum charge are not billed.
Before starting a run, Apify displays the event price and lets you set a **maximum charge per run**. The Actor respects that limit and stops starting new queries when the remaining budget cannot fund another requested result batch. The final price can therefore be lower than the theoretical maximum if DuckDuckGo returns fewer results or the run reaches the spending limit.
Maximum estimated result charge:
```text
number of queries × maxResultsPerQuery × $0.00015
```
For example, 100 queries with a maximum of 30 results each have a maximum result charge of `100 × 30 × $0.00015 = $0.45`.
### Tips for reliable searches
- Start with a small run to confirm that the selected region and query wording return the expected market.
- Increase both `maxResultsPerQuery` and `maxPagesPerQuery` when you need deeper rankings.
- Use a specific regional code for local SEO research. `wt-wt` does not force a country market.
- Use the same query, region, and Safe Search values across scheduled runs when comparing rankings over time.
- Use `resultId` for query-specific deduplication and `queryId` to group results from the same search settings.
- Set a maximum charge before large runs to keep spending predictable.
### Limitations
- The Actor currently supports DuckDuckGo organic web results only. It does not return ads, images, news, videos, maps, or shopping results.
- DuckDuckGo controls which results are available and how many appear on each page, so the requested maximum is not guaranteed.
- Rankings can change with time, region, language, Safe Search settings, and changes made by DuckDuckGo.
- `description`, `displayUrl`, or `domain` can be `null` when the source result does not provide a usable value.
- The maximum input is 1,000 unique queries, 100 results per query, and 10 pages per query.
- Search-page changes or temporary access restrictions can cause an individual query to finish as partial or failed. Other queries continue independently.
### Frequently asked questions
#### Does this Actor scrape DuckDuckGo advertisements?
No. Only organic web results are delivered and billed.
#### Can it scrape image, news, or video search?
Not currently. The output contract is intentionally focused on clean organic web results.
#### Why did I receive fewer results than requested?
The page limit may have been reached, DuckDuckGo may have returned fewer results, duplicate URLs may have been removed, no additional page may have been available, a query may have exhausted its retries, or the run may have reached its maximum charge. Check `paginationStoppedReason` and the **Query diagnostics** link in the Output tab.
#### Is `position` the paid or organic ranking?
It is the organic ranking within the results delivered for that query. Ads are excluded.
#### Are duplicate queries processed twice?
No. Leading and trailing whitespace is removed, repeated internal whitespace is normalized, and duplicate queries are removed case-insensitively. The first spelling of each query is retained.
#### Do I need to configure a proxy?
No. Proxy handling is managed by the Actor and is not part of the user input.
#### Can I schedule ranking checks?
Yes. Save your input as an Apify Task, attach a Schedule, and export or forward each completed dataset using an integration or webhook.
#### Is web scraping legal?
This Actor collects publicly visible search-result metadata. You are responsible for ensuring that your use complies with applicable laws, contractual requirements, and the rights of third parties. If your use case involves personal data or regulated information, obtain appropriate legal advice.
### Support
If a run does not behave as expected, open the Actor's **Issues** tab and include:
- the Apify run ID;
- the input used, without API tokens or other secrets;
- the query and region affected;
- the expected and actual behavior.
This information makes it possible to reproduce and resolve the problem quickly.
# Actor input Schema
## `queries` (type: `array`):
One query per line. Duplicate and blank queries are removed automatically.
## `maxResultsPerQuery` (type: `integer`):
Maximum number of unique organic results delivered for each query.
## `maxPagesPerQuery` (type: `integer`):
Maximum number of DuckDuckGo result pages followed for each query.
## `region` (type: `string`):
Regional market used to localize DuckDuckGo results.
## `safeSearch` (type: `string`):
Controls filtering of explicit search results.
## Actor input object example
```json
{
"queries": [
"python web scraping"
],
"maxResultsPerQuery": 10,
"maxPagesPerQuery": 1,
"region": "wt-wt",
"safeSearch": "Moderate"
}
```
# Actor output Schema
## `results` (type: `string`):
The default dataset. Each item is one delivered organic result and one billable event.
## `summary` (type: `string`):
Aggregate query, pagination, retry, delivery, and billing counters.
## `queryStatuses` (type: `string`):
Free diagnostics for empty, failed, partial, or budget-skipped queries.
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"queries": [
"python web scraping"
]
};
// Run the Actor and wait for it to finish
const run = await client.actor("datascraperes/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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = { "queries": ["python web scraping"] }
# Run the Actor and wait for it to finish
run = client.actor("datascraperes/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": [
"python web scraping"
]
}' |
apify call datascraperes/duckduckgo-search-results-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=datascraperes/duckduckgo-search-results-scraper",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "DuckDuckGo Search Scraper — Organic SERP API",
"description": "Get clean, paginated DuckDuckGo organic search results with rank, title, URL, domain, and snippet. Fast HTTP, 68 regions, and pay-per-result pricing.",
"version": "0.1",
"x-build-id": "ZSfIR1C2Fv5D1BSHN"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/datascraperes~duckduckgo-search-results-scraper/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-datascraperes-duckduckgo-search-results-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/datascraperes~duckduckgo-search-results-scraper/runs": {
"post": {
"operationId": "runs-sync-datascraperes-duckduckgo-search-results-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/datascraperes~duckduckgo-search-results-scraper/run-sync": {
"post": {
"operationId": "run-sync-datascraperes-duckduckgo-search-results-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",
"required": [
"queries"
],
"properties": {
"queries": {
"title": "Search queries",
"minItems": 1,
"maxItems": 1000,
"type": "array",
"description": "One query per line. Duplicate and blank queries are removed automatically.",
"items": {
"type": "string",
"minLength": 1,
"maxLength": 500
},
"default": [
"python web scraping"
]
},
"maxResultsPerQuery": {
"title": "Maximum results per query",
"minimum": 1,
"maximum": 100,
"type": "integer",
"description": "Maximum number of unique organic results delivered for each query.",
"default": 10
},
"maxPagesPerQuery": {
"title": "Maximum pages per query",
"minimum": 1,
"maximum": 10,
"type": "integer",
"description": "Maximum number of DuckDuckGo result pages followed for each query.",
"default": 1
},
"region": {
"title": "Results region",
"enum": [
"wt-wt",
"us-en",
"ue-es",
"uk-en",
"es-es",
"xl-es",
"mx-es",
"ar-es",
"cl-es",
"co-es",
"pe-es",
"ve-es",
"ca-en",
"ca-fr",
"br-pt",
"pt-pt",
"fr-fr",
"de-de",
"it-it",
"nl-nl",
"be-fr",
"be-nl",
"ch-de",
"ch-fr",
"ch-it",
"at-de",
"ie-en",
"au-en",
"nz-en",
"in-en",
"jp-jp",
"kr-kr",
"cn-zh",
"hk-tzh",
"tw-tzh",
"sg-en",
"my-ms",
"my-en",
"id-id",
"id-en",
"ph-en",
"ph-tl",
"th-th",
"vn-vi",
"tr-tr",
"pl-pl",
"cz-cs",
"sk-sk",
"ro-ro",
"hu-hu",
"gr-el",
"bg-bg",
"hr-hr",
"sl-sl",
"dk-da",
"fi-fi",
"no-no",
"se-sv",
"ee-et",
"lv-lv",
"lt-lt",
"ua-uk",
"ru-ru",
"il-he",
"za-en",
"xa-ar",
"xa-en",
"ct-ca"
],
"type": "string",
"description": "Regional market used to localize DuckDuckGo results.",
"default": "wt-wt"
},
"safeSearch": {
"title": "Safe Search",
"enum": [
"Strict",
"Moderate",
"Off"
],
"type": "string",
"description": "Controls filtering of explicit search results.",
"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
}
}
}
}
}
}
}
}
}
}
```