# Duckduckgo Scraper (`simpleapi/duckduckgo-scraper`) Actor

DuckDuckGo Scraper delivers accurate, privacy-friendly search result data from DuckDuckGo. Extract titles, links, and snippets for research, monitoring, and content planning. Built for scalable scraping and clean structured output.

- **URL**: https://apify.com/simpleapi/duckduckgo-scraper.md
- **Developed by:** [SimpleAPI](https://apify.com/simpleapi) (community)
- **Categories:** Automation, SEO tools, Developer tools
- **Stats:** 1 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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 Scraper helps you collect clean, unbiased search data directly from DuckDuckGo with ease. 🚀 Whether you’re a developer, researcher, or analyst, it enables fast access to search results, links, and insights without personalization influence, making data collection simple, reliable, and flexible.

### 🔍 What is Duckduckgo Scraper?

Duckduckgo Scraper is a powerful tool designed to extract public search data directly from DuckDuckGo results pages in a structured format. 🚀  
It allows users to collect search listings, titles, descriptions, URLs, and related data without manual copying.

Unlike traditional browsing, a duckduckgo web scraper automates large-scale data collection while respecting DuckDuckGo’s privacy-focused environment. This makes it especially useful for researchers, developers, analysts, and marketers who need clean, unbiased search data.

With support for duckduckgo scraping, users can retrieve information efficiently for content analysis, competitive research, and dataset building. Many users prefer a duckduckgo scraper free version or explore duckduckgo scraper github repositories for testing and experimentation.

✨ Whether used as a duckduckgo scraper online, a local script, or a duckduckgo scraper app, it provides fast, repeatable, and scalable data extraction without personalization bias.

* * *

### 📊 What Duckduckgo Scraper can I extract?

A Duckduckgo Scraper supports multiple data types from search result pages, making it suitable for various professional use cases. 🧩  
Below is a clear breakdown of extractable elements.

| 📌 Data Type | 📄 Description |
| --- | --- |
| Search Titles | Headline text from DuckDuckGo results |
| Result URLs | Destination links from each listing |
| Meta Descriptions | Summary snippets shown in results |
| Search Rank | Position of each result |
| Related Searches | Suggested queries by DuckDuckGo |
| Image URLs | Data from duckduckgo image scraper |
| Instant Answers | Featured or direct answers |
| Timestamp (if available) | Indexed or detected publish time |

Using duckduckgo search scraper functionality, users can collect consistent datasets without personalization interference. Developers often combine duckduckgo scraper python scripts with automation workflows, while analysts rely on duckduckgo scraping python for repeatable data pulls.

This flexibility also makes duckduckgo proxy scraper setups popular for handling larger volumes of queries reliably.

* * *

#### ⭐ Key Features of Duckduckgo Scraper

A modern Duckduckgo Scraper is packed with features that make data extraction smooth and reliable:

*   ⚡ Fast search result extraction with minimal setup  
      
    
*   🔒 Privacy-friendly scraping aligned with DuckDuckGo’s philosophy  
      
    
*   🧠 Clean, structured output for easy analysis  
      
    
*   🖼️ Built-in support for duckduckgo image scraper tasks  
      
    
*   🌍 Works with multiple regions and languages  
      
    
*   🔁 Scalable for large keyword lists  
      
    
*   🧩 Compatible with duckduckgo api\-style workflows  
      
    
*   🐍 Easy integration with duckduckgo scraper python scripts  
      
    
*   🌐 Can run as a duckduckgo scraper online or local tool  
      
    
*   🔄 Proxy support for high-volume requests  
      
    

Many developers explore duckduckgo scraper github projects to customize features or build their own duckduckgo scraper api solutions for internal tools and dashboards.

* * *

### 🛠️ How to use Duckduckgo Scraper

Using a Duckduckgo Scraper is straightforward, even for beginners. Follow these simple steps 👇

#### Step-by-Step Guide

1️⃣ Log in to Apify

 Create a free account or sign in to your dashboard.

2️⃣ Select the Actor

 Search for Duckduckgo Scraper in the Apify store.

3️⃣ Enter Input Data

 Add your search queries or keywords in the input field.

4️⃣ Choose Options

 Select result limits, region, language, or image extraction if needed.

5️⃣ Run the Actor

 Click start and let the duckduckgo web scraper collect results.

6️⃣ Download Results

 Export data in JSON, CSV, or Excel format.

This process works well for users building duckduckgo scraper app solutions or automating workflows using duckduckgo scraping python.

* * *

### 🎯 Use Cases

A Duckduckgo Scraper supports a wide range of real-world applications:

*   📈 Market research – Analyze unbiased search visibility  
      
    
*   📝 Content research – Discover ranking pages and topics  
      
    
*   🧪 Academic research – Collect neutral datasets  
      
    
*   🛒 E-commerce analysis – Track competitor visibility  
      
    
*   📸 Media projects – Use duckduckgo image scraper for visuals  
      
    
*   🧩 App development – Feed data into dashboards or tools  
      
    
*   🐍 Python automation – Integrate with duckduckgo scraping python scripts  
      
    

Because DuckDuckGo avoids personalized results, data collected via a duckduckgo search scraper offers a clearer picture of general search behavior.

* * *

### 💡 Why choose us?

Our Duckduckgo Scraper stands out for reliability, simplicity, and scalability 🌟

*   ✅ Trusted by developers and analysts worldwide  
      
    
*   ⚙️ Designed for both beginners and advanced users  
      
    
*   📦 Clean, structured outputs ready for analysis  
      
    
*   🔌 Easy integration with duckduckgo scraper api workflows  
      
    
*   🛡️ Stable performance with proxy support  
      
    
*   🌐 Works as duckduckgo scraper online or automated task  
      
    
*   📚 Well-documented and production-ready  
      
    

Whether you’re exploring a duckduckgo scraper free option or building a professional data pipeline, our solution adapts effortlessly to your needs.

* * *

### 📈 How many results can you scrape with Duckduckgo Scraper?

The Duckduckgo Scraper is built for flexibility and scale. 🔄  
You can extract dozens, hundreds, or thousands of results, depending on your configuration and query volume.

For small projects, users often scrape a few keywords using a duckduckgo scraper python script. For larger datasets, the scraper can process bulk keyword lists efficiently while maintaining consistent output quality.

Key scalability highlights include:

*   📊 Adjustable result limits per query  
      
    
*   🔁 Batch keyword processing  
      
    
*   🌍 Multi-region support  
      
    
*   🧩 Proxy compatibility for continuous runs  
      
    
*   🗂️ Structured storage for large datasets  
      
    

Developers building tools with duckduckgo scraper api setups can scale extraction seamlessly. Many teams also extend functionality using duckduckgo scraper github projects to match custom requirements.

From quick checks to enterprise-level collection, duckduckgo scraping adapts smoothly without sacrificing reliability.

* * *

### ⚖️ Is it legal to scrape Duckduckgo?

Scraping DuckDuckGo search results is generally acceptable when done responsibly and ethically. 🧠

Important considerations include:

*   📜 Respect DuckDuckGo’s terms of service  
      
    
*   🔍 Collect only publicly available data  
      
    
*   🚫 Avoid excessive request rates  
      
    
*   🧾 Use data for lawful purposes  
      
    
*   🔐 Do not collect personal or sensitive information  
      
    

Using a duckduckgo web scraper for research, analysis, or internal tools is common practice. Many developers rely on duckduckgo scraping python responsibly by limiting request frequency and honoring usage guidelines.

When in doubt, consulting legal advice is always recommended.

* * *

### 🧾 Input Parameters

#### Example Input (JSON)

 ```json
{
  "searchKeyword": "Python",
  "searchMode": "default",
  "region": "wt-wt",
  "safeSearch": "OFF",
  "maxItems": 20,
  "endPage": 1,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

### 📤 Output Format

#### Example Output (JSON)

```json
  {
    "query": "javascript",
    "searchMode": "default",
    "title": "How to enable JavaScript in Windows - Microsoft Support",
    "description": "Learn how to enable JavaScript in web browsers to access features and content on many Internet Web sites. Follow the steps for Internet Explorer, Google Chrome, and Firefox.",
    "rawDescription": "Learn how to enable JavaScript in web browsers to access features and content on many Internet Web sites. Follow the steps for Internet Explorer, Google Chrome, and Firefox.",
    "hostname": "support.microsoft.com/en-us/topic/how-to-enable-javascript-in-windows-88d27b37-6484-7fc0-17df-872f65168279",
    "icon": "https://external-content.duckduckgo.com/ip3/support.microsoft.com/en-us/topic/how-to-enable-javascript-in-windows-88d27b37-6484-7fc0-17df-872f65168279.ico",
    "url": "https://support.microsoft.com/en-us/topic/how-to-enable-javascript-in-windows-88d27b37-6484-7fc0-17df-872f65168279"
  },
```

### ❓ FAQ

#### 1️⃣ Is Duckduckgo Scraper free to use?

Yes, many users start with a duckduckgo scraper free plan or open-source tools.

#### 2️⃣ Can I use Duckduckgo Scraper with Python?

Absolutely! duckduckgo scraper python and duckduckgo scraping python are very popular.

#### 3️⃣ Is there a Duckduckgo Scraper API?

Yes, many tools offer duckduckgo scraper api style access.

#### 4️⃣ Can I scrape images from DuckDuckGo?

Yes, using a duckduckgo image scraper.

#### 5️⃣ Does Duckduckgo Scraper support proxies?

Yes, duckduckgo proxy scraper setups are supported.

#### 6️⃣ Are GitHub projects available?

Yes, explore duckduckgo scraper github repositories.

#### 7️⃣ Can I run it online without installation?

Yes, a duckduckgo scraper online works directly in the browser.

### ✅ Conclusion

With Duckduckgo Scraper, extracting public search data becomes efficient and scalable. 🌐 From quick keyword checks to large datasets, it supports multiple use cases through flexible setups and structured outputs. If you need privacy-focused search insights with consistent results, this tool is a dependable choice.

***

✨ Duckduckgo Scraper offers a clean, powerful, and flexible way to collect unbiased search data — perfect for research, development, and analysis at any scale.

# Actor input Schema

## `searchKeyword` (type: `string`):

The keyword that you can search on DuckDuckGo

## `searchMode` (type: `string`):

What type of results you want to search on at DuckDuckGo.

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

Region that you want to get the results from DuckDuckGo.

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

Safe mode when searching over DuckDuckGo

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

Maximum number of listing items that you want as output. Default is all

## `endPage` (type: `integer`):

The page number that you want to end with. By default there is no end page. This is applies to all search request and startUrls individually.

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

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "searchKeyword": "javascript",
  "searchMode": "default",
  "region": "wt-wt",
  "safeSearch": "OFF",
  "maxItems": 20,
  "endPage": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = { "proxyConfiguration": { "useApifyProxy": False } }

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

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

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

```

## CLI example

```bash
echo '{
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call simpleapi/duckduckgo-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Duckduckgo Scraper",
        "description": "DuckDuckGo Scraper delivers accurate, privacy-friendly search result data from DuckDuckGo. Extract titles, links, and snippets for research, monitoring, and content planning. Built for scalable scraping and clean structured output.",
        "version": "0.1",
        "x-build-id": "xB1dkCtPoQ5Uz6OOh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/simpleapi~duckduckgo-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-simpleapi-duckduckgo-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/simpleapi~duckduckgo-scraper/runs": {
            "post": {
                "operationId": "runs-sync-simpleapi-duckduckgo-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/simpleapi~duckduckgo-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-simpleapi-duckduckgo-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": [
                    "searchKeyword",
                    "searchMode",
                    "region",
                    "safeSearch"
                ],
                "properties": {
                    "searchKeyword": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "The keyword that you can search on DuckDuckGo",
                        "default": "javascript"
                    },
                    "searchMode": {
                        "title": "Search Mode",
                        "enum": [
                            "default",
                            "images",
                            "news",
                            "videos"
                        ],
                        "type": "string",
                        "description": "What type of results you want to search on at DuckDuckGo.",
                        "default": "default"
                    },
                    "region": {
                        "title": "Region",
                        "enum": [
                            "wt-wt",
                            "ar-es",
                            "au-en",
                            "at-de",
                            "be-fr",
                            "be-nl",
                            "br-pt",
                            "bg-bg",
                            "ca-en",
                            "ca-fr",
                            "ct-ca",
                            "cl-es",
                            "cn-zh",
                            "co-es",
                            "hr-hr",
                            "cz-cs",
                            "dk-da",
                            "ee-et",
                            "fi-fi",
                            "fr-fr",
                            "de-de",
                            "gr-el",
                            "hk-tzh",
                            "hu-hu",
                            "in-en",
                            "id-en",
                            "ie-en",
                            "il-en",
                            "it-it",
                            "jp-jp",
                            "kr-kr",
                            "lv-lv",
                            "lt-lt",
                            "my-en",
                            "mx-es",
                            "nl-nl",
                            "nz-en",
                            "no-no",
                            "pk-en",
                            "pe-es",
                            "ph-en",
                            "pl-pl",
                            "pt-pt",
                            "ro-ro",
                            "ru-ru",
                            "xa-ar",
                            "sg-en",
                            "sk-sk",
                            "sl-sl",
                            "za-en",
                            "es-ca",
                            "es-es",
                            "se-sv",
                            "ch-de",
                            "ch-fr",
                            "tw-tzh",
                            "th-en",
                            "tr-tr",
                            "us-en",
                            "us-es",
                            "ua-uk",
                            "uk-en",
                            "vn-en"
                        ],
                        "type": "string",
                        "description": "Region that you want to get the results from DuckDuckGo.",
                        "default": "wt-wt"
                    },
                    "safeSearch": {
                        "title": "Safe Search",
                        "enum": [
                            "OFF",
                            "MODERATE",
                            "STRICT"
                        ],
                        "type": "string",
                        "description": "Safe mode when searching over DuckDuckGo",
                        "default": "OFF"
                    },
                    "maxItems": {
                        "title": "Maximum number of listing items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of listing items that you want as output. Default is all",
                        "default": 20
                    },
                    "endPage": {
                        "title": "List end page",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "The page number that you want to end with. By default there is no end page. This is applies to all search request and startUrls individually.",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies to be used by your crawler."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```