# DuckDuckGo Scraper (`johnvc/duckduckgo-scraper-for-serp-rankings`) Actor

DuckDuckGo search scraper that extracts comprehensive search results including organic results, ads, knowledge graph, news, inline images, videos, and related searches. Features localization, safe search, and date. Perfect for market research, SEO analysis, and competitive intelligence.

- **URL**: https://apify.com/johnvc/duckduckgo-scraper-for-serp-rankings.md
- **Developed by:** [John](https://apify.com/johnvc) (community)
- **Categories:** SEO tools, Developer tools, Other
- **Stats:** 50 total users, 7 monthly users, 100.0% runs succeeded, 8 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.01 / 1,000 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 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

## DuckDuckGo Search Scraper

Scrape DuckDuckGo search results as structured JSON. Returns organic results, ads, knowledge graph, news, inline images, inline videos, and related searches in a single dataset item per page. Localize across 40+ regions, filter by date or safe-search level, and paginate with a configurable page cap.

Built for SEO researchers, AI agents, and developers who need a reliable DuckDuckGo SERP API without monthly rental fees.

### What you get

Each dataset item is one page of search results. Per page, the Actor returns:

- **Organic results** - title, link, snippet, position, displayed link, thumbnail, favicon, date, rich snippet, sitelinks
- **Ads** - same fields where DuckDuckGo surfaces sponsored entries
- **Knowledge graph** - entity panel data when DuckDuckGo includes one
- **News results** - headline, source, date, link, thumbnail
- **Inline images** and **inline videos** - in-SERP media blocks
- **Related searches** - DuckDuckGo's suggested follow-up queries
- **Pagination metadata** - page number, total found, whether the page cap stopped the run

### Use cases

- **SEO research** - track rankings for target keywords across regions
- **AI agent grounding** - feed live DuckDuckGo results into an LLM via the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp)
- **Competitive monitoring** - capture ads and knowledge graph entries for brand terms
- **News monitoring** - filter to the past day or week for fresh coverage
- **Privacy-conscious search analytics** - DuckDuckGo does not personalize results, so output is consistent across runs

### Input parameters

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `query` | string | yes | `"python tutorial"` | Search term to query on DuckDuckGo |
| `localization` | string | no | `"us-en"` | Region/language code from 40+ supported regions (e.g. `uk-en`, `fr-fr`, `de-de`, `jp-jp`) |
| `safe` | string | no | `"moderate"` | Safe-search level: `strict`, `moderate`, or `off` |
| `date_filter` | string | no | (none) | `d` (24h), `w` (week), `m` (month), `y` (year), or a custom range `YYYY-MM-DD..YYYY-MM-DD` |
| `max_pages` | integer | no | `2` | Maximum pages to fetch. `0` means no limit (paginate until DuckDuckGo runs out of results) |
| `output_file` | string | no | (none) | Optional custom filename if you want a single JSON file in addition to the dataset |

### Example input

Basic:
```json
{
  "query": "python tutorial"
}
````

Localized with date and safe-search filter, 3 pages:

```json
{
  "query": "machine learning",
  "localization": "uk-en",
  "safe": "strict",
  "date_filter": "w",
  "max_pages": 3
}
```

### Example output

One dataset item per page. Abbreviated:

```json
{
  "query": "machine learning",
  "localization": "uk-en",
  "safe_search": 1,
  "date_filter": "w",
  "max_pages": 3,
  "page_number": 1,
  "total_results_found": 150,
  "pages_processed": 3,
  "search_metadata": {
    "localization": "uk-en",
    "localization_name": "United Kingdom (English)",
    "safe_search": 1,
    "safe_search_description": "Strict",
    "date_filter": "w",
    "max_pages": 3,
    "pagination_limit_reached": false
  },
  "pagination_info": {
    "total_pages": 3,
    "max_pages_set": 3,
    "pagination_stopped_by_limit": false,
    "results_per_page": {
      "first_page": 30,
      "subsequent_pages": 50
    }
  },
  "organic_results": [
    {
      "position": 1,
      "title": "Machine Learning Tutorial",
      "link": "https://example.com/ml-tutorial",
      "displayed_link": "example.com",
      "snippet": "Learn machine learning fundamentals...",
      "thumbnail": "https://thumbnail.url",
      "favicon": "https://favicon.url",
      "date": "2026-04-15",
      "rich_snippet": "Rich snippet content...",
      "sitelinks": []
    }
  ],
  "ads": [],
  "knowledge_graph": [],
  "news_results": [],
  "inline_images": [],
  "inline_videos": [],
  "related_searches": []
}
```

### Pricing

Pay-per-event. No monthly rental.

| Event | Cost | When charged |
|---|---|---|
| `setup` | $0.01 | Once per run |
| `page_processed` | $0.02 | Once per page returned |

Typical cost: a 3-page run is $0.07 ($0.01 setup + 3 x $0.02 pages). The first page typically returns 30 results; subsequent pages return up to 50 each.

### Getting started

1. Open the Actor in the [Apify Console](https://apify.com/) and click **Try for free**.
2. Enter a `query` (the only required field). Optionally set `localization`, `safe`, `date_filter`, and `max_pages`.
3. Click **Start** - the run takes 5-15 seconds per page.
4. Open the **Dataset** tab to view, filter, or export results as JSON, CSV, or Excel.

Programmatic use - via the [Apify API](https://docs.apify.com/api/v2):

```bash
curl -X POST "https://api.apify.com/v2/acts/<actor-id>/runs?token=<APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"query":"python tutorial","localization":"us-en","max_pages":2}'
```

For AI agents - the Actor is discoverable through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp). Connect Cursor, Claude.ai, VS Code, Claude Code, or any MCP-compatible client to `https://mcp.apify.com` and call `search-actors` with "duckduckgo search results".

### FAQ

**Do I need my own API credentials?**  No - the Actor uses a backing search API and the Apify console handles credentials for you. Just provide a `query` and run it.

**How many results per page?**  DuckDuckGo returns ~30 organic results on page 1 and up to 50 on subsequent pages. The exact count varies by query and region.

**Why is `max_pages: 0` slow?**  Setting `0` means "no cap" - the Actor paginates until DuckDuckGo exhausts results, which can be 10+ pages for broad queries. Use `max_pages: 5` if you only need the top results.

**Can I filter to a specific date range?**  Yes. Pass `date_filter` as `YYYY-MM-DD..YYYY-MM-DD` (e.g. `2026-01-01..2026-05-01`). For relative ranges use `d`, `w`, `m`, or `y`.

**What regions does `localization` support?**  40+ region/language combinations. Common values: `us-en`, `uk-en`, `ca-en`, `au-en`, `de-de`, `fr-fr`, `es-es`, `it-it`, `jp-jp`, `cn-zh`, `ru-ru`. The full list is in the input dropdown.

**The Actor returned 0 results - what happened?**  DuckDuckGo returns no results for the query/locale/date combination. Try broadening the query, removing `date_filter`, or switching to `localization: "us-en"`.

**Where do I report a bug or request a feature?**  Open an issue on the [GitHub repo](https://github.com/johnisanerd/Apify-DuckDuckGo-Search-Scraper) or contact the Actor maintainer through the Apify store page.

### Links

- [DuckDuckGo](https://duckduckgo.com/) - the search engine being scraped
- [Apify MCP integration docs](https://docs.apify.com/platform/integrations/mcp)
- [GitHub repo](https://github.com/johnisanerd/Apify-DuckDuckGo-Search-Scraper)

***

### n8n integration

Available as an n8n community node, **[n8n-nodes-duckduckgo-search-api](https://www.npmjs.com/package/n8n-nodes-duckduckgo-search-api)**. In n8n: Settings, Community Nodes, install `n8n-nodes-duckduckgo-search-api`, then use it in any workflow (it also works as an AI Agent tool).

***

### Featured Tasks

Ready-to-run examples that show this API solving a specific problem. Each opens its own setup so you can
run it on your account in one click.

- [Add DuckDuckGo web search to Claude via MCP](https://apify.com/johnvc/DuckDuckGoSEOScraper/examples/add-duckduckgo-web-search-to-claude-via-mcp?fpr=9n7kx3) - live DuckDuckGo web search inside Claude chat via MCP.
- [Scrape DuckDuckGo search results to CSV](https://apify.com/johnvc/DuckDuckGoSEOScraper/examples/scrape-duckduckgo-search-results-to-csv?fpr=9n7kx3) - every DuckDuckGo result with position, title, link, and snippet, export ready.
- [Check your domain rankings on DuckDuckGo](https://apify.com/johnvc/DuckDuckGoSEOScraper/examples/check-your-domain-rankings-on-duckduckgo?fpr=9n7kx3) - DuckDuckGo positions for any query so you can track rankings beyond Google.

***

Last Updated: 2026.06.17

# Actor input Schema

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

Search DuckDuckGo for this term. Used as the `q` parameter on the backing search request.

## `localization` (type: `string`):

Set the region and language for search results (e.g. `us-en`, `uk-en`, `fr-fr`, `de-de`, `jp-jp`). Defaults to `us-en` (United States English).

## `safe` (type: `string`):

Set the safe-search filter level. Use `strict` to block adult content, `moderate` for default filtering, or `off` for no filtering.

## `date_filter` (type: `string`):

Filter results by date. Use `d` for the past day, `w` for the past week, `m` for the past month, `y` for the past year, or a custom range like `2026-01-01..2026-05-01`.

## `max_pages` (type: `integer`):

Set the maximum number of result pages to fetch. Use `0` for no limit. Default is `2` to control costs - each page is billed separately.

## `output_file` (type: `string`):

Save results to this filename in the run's key-value store in addition to the dataset. Leave empty to skip the file output.

## Actor input object example

```json
{
  "query": "python tutorial",
  "localization": "us-en",
  "safe": "moderate",
  "max_pages": 2
}
```

# Actor output Schema

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

All search results stored in the default dataset. Each item contains one page of results with organic results, ads, knowledge graph, news, images, videos, and related searches.

# 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 = {
    "query": "python tutorial"
};

// Run the Actor and wait for it to finish
const run = await client.actor("johnvc/duckduckgo-scraper-for-serp-rankings").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 = { "query": "python tutorial" }

# Run the Actor and wait for it to finish
run = client.actor("johnvc/duckduckgo-scraper-for-serp-rankings").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 '{
  "query": "python tutorial"
}' |
apify call johnvc/duckduckgo-scraper-for-serp-rankings --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "DuckDuckGo Scraper",
        "description": "DuckDuckGo search scraper that extracts comprehensive search results including organic results, ads, knowledge graph, news, inline images, videos, and related searches. Features localization, safe search, and date. Perfect for market research, SEO analysis, and competitive intelligence.",
        "version": "0.0",
        "x-build-id": "I5opqfLWBB23dJy3b"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/johnvc~duckduckgo-scraper-for-serp-rankings/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-johnvc-duckduckgo-scraper-for-serp-rankings",
                "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/johnvc~duckduckgo-scraper-for-serp-rankings/runs": {
            "post": {
                "operationId": "runs-sync-johnvc-duckduckgo-scraper-for-serp-rankings",
                "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/johnvc~duckduckgo-scraper-for-serp-rankings/run-sync": {
            "post": {
                "operationId": "run-sync-johnvc-duckduckgo-scraper-for-serp-rankings",
                "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": [
                    "query"
                ],
                "properties": {
                    "query": {
                        "title": "Search Query",
                        "minLength": 1,
                        "type": "string",
                        "description": "Search DuckDuckGo for this term. Used as the `q` parameter on the backing search request."
                    },
                    "localization": {
                        "title": "Localization / Region",
                        "enum": [
                            "us-en",
                            "uk-en",
                            "ca-en",
                            "au-en",
                            "de-de",
                            "fr-fr",
                            "es-es",
                            "it-it",
                            "nl-nl",
                            "pl-pl",
                            "pt-br",
                            "ru-ru",
                            "ja-jp",
                            "ko-kr",
                            "zh-cn",
                            "zh-tw",
                            "hi-in",
                            "ar-sa",
                            "tr-tr",
                            "sv-se",
                            "da-dk",
                            "no-no",
                            "fi-fi",
                            "cs-cz",
                            "hu-hu",
                            "ro-ro",
                            "bg-bg",
                            "hr-hr",
                            "sk-sk",
                            "sl-si",
                            "et-ee",
                            "lv-lv",
                            "lt-lt",
                            "mt-mt",
                            "el-gr",
                            "cy-cy",
                            "is-is",
                            "mk-mk",
                            "sq-al",
                            "sr-rs",
                            "bs-ba",
                            "me-me"
                        ],
                        "type": "string",
                        "description": "Set the region and language for search results (e.g. `us-en`, `uk-en`, `fr-fr`, `de-de`, `jp-jp`). Defaults to `us-en` (United States English).",
                        "default": "us-en"
                    },
                    "safe": {
                        "title": "Safe Search",
                        "enum": [
                            "strict",
                            "moderate",
                            "off"
                        ],
                        "type": "string",
                        "description": "Set the safe-search filter level. Use `strict` to block adult content, `moderate` for default filtering, or `off` for no filtering.",
                        "default": "moderate"
                    },
                    "date_filter": {
                        "title": "Date Filter",
                        "pattern": "^(d|w|m|y|\\d{4}-\\d{2}-\\d{2}\\.\\.\\d{4}-\\d{2}-\\d{2})$",
                        "type": "string",
                        "description": "Filter results by date. Use `d` for the past day, `w` for the past week, `m` for the past month, `y` for the past year, or a custom range like `2026-01-01..2026-05-01`."
                    },
                    "max_pages": {
                        "title": "Maximum Pages",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Set the maximum number of result pages to fetch. Use `0` for no limit. Default is `2` to control costs - each page is billed separately.",
                        "default": 2
                    },
                    "output_file": {
                        "title": "Output Filename",
                        "type": "string",
                        "description": "Save results to this filename in the run's key-value store in addition to the dataset. Leave empty to skip the file output."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
