# Reddit Posts Scraper (`api-empire/reddit-posts-scraper`) Actor

Extract structured Reddit post data at scale. This actor gathers titles, scores, authors, dates, and engagement stats from any subreddit. Ideal for analysts, marketers, and developers who need reliable Reddit insights for monitoring or automation.

- **URL**: https://apify.com/api-empire/reddit-posts-scraper.md
- **Developed by:** [API Empire](https://apify.com/api-empire) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 7 total users, 0 monthly users, 100.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

### 🔍 What Does a Reddit Posts Scraper Do?🤖

A Reddit Posts Scraper is a powerful automation tool that extracts public Reddit content such as posts, comments, authors, timestamps, engagement metrics, and more—all in structured, ready-to-use formats. Whether you're analyzing trends, monitoring brand sentiment, researching competitors, or gathering data for machine learning, a scraper simplifies the entire workflow.

This tool is widely used by marketers, data scientists, content creators, and researchers looking to extract insights at scale. With SEO-friendly data outputs, the Reddit Posts Scraper also helps enrich content strategies, keyword research models, and market intelligence systems.

Whether you prefer reddit scraper GitHub, reddit scraper Python, or a reddit scraper free solution, this Actor provides a user-friendly and scalable way to access Reddit data instantly.

* * *

### 📥 What Reddit Data Can I Extract?

The Reddit Posts Scraper supports extracting a wide range of structured data. Below is a clear breakdown

  

| Data Type | Description |
| --- | --- |
| 📝 Post Title | Extracts the full title of each Reddit post. |
| 🧵 Post Body | Captures full post text (if available). |
| 🔗 Post URL | Direct link to each Reddit thread. |
| 📅 Timestamp | Date & time of posting. |
| 📊 Upvotes & Score | Engagement metrics for analysis. |
| 👤 Author Name | Reddit username of the poster. |
| 🏷️ Subreddit | Category or community name. |
| 💬 Top Comments | Ideal for reddit comment scraper needs. |
| 🖼️ Media Links | Images, videos, embeds. |
| 🔥 Awards | Gold, Silver, and other Reddit awards. |

  

* * *

#### ⭐ Key Features of the Reddit Posts Scraper

This scraper is loaded with powerful capabilities to make Reddit data extraction seamless, fast, and customizable.

#### ✨ Highlights:

*   Extract posts, comments, media & metadata in one run.  
      
    
*   Supports multiple subreddits, search queries, and post URLs.  
      
    
*   Works with date ranges, filters, and post sorting options.  
      
    
*   Fully compatible with Apify Reddit Scraper ecosystem.  
      
    
*   Can serve as a reddit scraper API alternative with no coding needed.  
      
    
*   Ideal for teams that want a reddit scraper free or low-cost solution.  
      
    
*   Supports workflows like n8n reddit scraper automation, Google Sheets syncing & Zapier.  
      
    
*   Developer-friendly for those using reddit scraper GitHub or reddit scraper Python.  
      
    
*   Extracts both hot, new, top, and controversial posts.  
      
    
*   Clean JSON output—perfect for NLP, ML training, dashboards, and analytics.  
      
    

This feature-rich setup makes it one of the best Reddit Posts Scraper tools available online today.

  

* * *

### 🧠 How to Use the Reddit Posts Scraper (Step-by-Step)

Follow this simple guide to run your scraper efficiently 👇

1.  🔐 Log in to Apify  
    Create a free Apify account or sign in to your dashboard.  
      
    
2.  🛠️ Select the Actor  
    Search for “Reddit Posts Scraper” or “Apify Reddit Scraper” in the Apify store.  
      
    
3.  📥 Enter Input Data  
    Add your subreddit names, post URLs, or search queries into the startUrls field.  
    You can scrape one or multiple pages at once.  
      
    
4.  ⚙️ Choose Options  
      
    

*   Enable timestamps  
      
    
*   Choose sorting (hot/top/new)  
      
    
*   Add filters such as post limit or time range  
      
    

6.  ▶️ Run the Actor  
    Click Start—the scraper gathers Reddit data automatically.  
      
    
7.  💾 Download Results  
    Export data in JSON, CSV, XLSX, or integrate via API.  
      
    

This simple workflow makes the scraper ideal for beginners and advanced users—including those looking for a reddit posts scraper free, reddit posts scraper online, or reddit posts scraper app solution.

* * *

### 🎯 Use Cases for the Reddit Posts Scraper

A Reddit scraper app opens endless opportunities across industries. Here are some powerful real-world examples:

#### 📊 Business & Market Research

Identify market trends, analyze pain points, and perform competitor monitoring using aggregated Reddit discussions.

#### 🧠 Machine Learning & NLP

Perfect for training sentiment models, topic classification, conversation analysis, and dataset creation.

#### 📝 Content & SEO Strategy

Find what people are talking about and create SEO-optimized content based on real community insights.

#### 📈 Brand Monitoring

Track mentions, feedback, reviews, and customer sentiment across communities.

#### 📰 Journalism & Research

Extract authentic opinions and narratives from communities for investigative work.

#### 🔄 Automation Workflows

Integrate with reddit scraper n8n, Zapier, or custom pipelines.

* * *

### 💡 Why Choose Us?

Choosing the right Reddit Posts Scraper is crucial—and here’s why this one stands out:

*   ⚡ Fast & Scalable — Handles thousands of posts efficiently.  
      
    
*   🧩 Flexible Inputs — Works with subreddits, keywords, post URLs, and custom filters.  
      
    
*   🛡️ Reliable & Stable — Built on the trusted Apify platform.  
      
    
*   📚 Perfect for Developers — Works like a reddit scraper API without coding.  
      
    
*   😊 Beginner-Friendly — No technical setup required.  
      
    
*   🔄 Integrations — Easily connect to n8n, Make, Zapier, Sheets, or APIs.  
      
    
*   ✔️ Best Value — Ideal for those looking for a reddit scraper free or low-cost solution.  
      
    

This makes it one of the best Reddit posts scraper tools available online.

* * *

### 📈 How Many Results Can You Scrape with the Reddit Posts Scraper?

Scalability is one of the strongest advantages of this tool. Whether you're scraping a single subreddit or hundreds, the scraper is built to handle large-scale data extraction smoothly.

#### 🚀 Performance Highlights:

*   Scrape hundreds of thousands of Reddit posts in a single workflow.  
      
    
*   Extract entire subreddit histories based on filters.  
      
    
*   Collect comments from thousands of threads, suitable for NLP datasets.  
      
    
*   Handle bulk URL imports, making it easy to run mass research projects.  
      
    
*   Download results in batches for convenience and speed.  
      
    

This flexibility makes the tool perfect for professional data analysts, agencies, academic researchers, machine learning teams, and automation workflows such as reddit scraper n8n.

Whether you're seeking a reddit scraper API, reddit posts scraper free, or best reddit scraper GitHub alternative, this solution gives you enterprise-grade scalability.

* * *

### ⚖️ Is It Legal to Scrape Reddit?

Scraping public Reddit data is generally legal when done responsibly and in compliance with platform policies.

#### 👍 Allowed:

*   Scraping publicly accessible content  
      
    
*   Using data for research, analytics, NLP, marketing insights  
      
    
*   Ensuring the scraper behaves ethically and avoids harmful actions  
      
    

#### ⚠️ Important:

*   Do not scrape private subreddits without permission  
      
    
*   Always respect Reddit’s robots.txt and terms  
      
    
*   Avoid personal data misuse  
      
    
*   Use rate limits to stay compliant  
      
    

This scraper is designed with ethical data extraction principles—making it a safe and compliant solution for anyone needing public Reddit insights.

* * *

### 🔧 Input Parameters

#### 📥 JSON Input Example
```json
{
  "startUrls": [
    { "url": "https://www.reddit.com/r/news/" },
    { "url": "https://www.reddit.com/r/technology/" },
    { "url": "artificial intelligence" }
  ],
  "sortOrder": "top",
  "maxPosts": 100,
  "maxComments": 50,
  "timeFilter": "week",
  "requestDelay": 2,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
````

### 📤 Output Format

#### 📦 JSON Output Example

```json
{
  "post_id": "abc123",
  "title": "Post Title",
  "author": "username",
  "created_utc": 1703123456.789,
  "num_comments": 42,
  "score": 156,
  "permalink": "/r/news/comments/abc123/post_title/",
  "image_url": "https://example.com/image.jpg",
  "thumbnail_url": "https://example.com/thumb.jpg",
  "body": "Post content...",
  "subreddit": "news",
  "comments": [
    {
      "author": "commenter1",
      "body": "Comment text...",
      "score": 23,
      "created_utc": 1703123456.789,
      "replies": [...]
    }
  ],
  "success": true,
  "error_message": null
}
```

## ❓ FAQ — Reddit Posts Scraper

#### 1️⃣ Is the Reddit Posts Scraper free?

Yes! You can run it on Apify with a free plan, ideal for small scraping jobs.

#### 2️⃣ Does it work like a Reddit scraper API?

Yes, the Actor outputs structured JSON, making it an excellent API-like alternative.

#### 3️⃣ Can I integrate it with n8n?

Absolutely — perfect for reddit scraper n8n automation flows.

#### 4️⃣ Is this better than a GitHub reddit scraper?

Yes — no coding, setup, or maintenance required.

#### 5️⃣ Can I scrape comments too?

Yes! It also works as a reddit comment scraper.

#### 6️⃣ Do I need coding skills?

No—it's beginner-friendly.

#### 7️⃣ Can I scrape multiple subreddits at once?

Yes, add as many as you like.

#### 8️⃣ Is it safe?

Yes, as long as you scrape publicly available data respectfully.

### ✅ Conclusion 🎯

The Reddit Posts Scraper is a powerful, scalable, and user-friendly tool for extracting Reddit posts, comments, and insights at any level. Whether you're a marketer, researcher, or developer, it delivers clean, structured data fast—making it one of the best Reddit scraping solutions available online today. 🚀

### What are other Reddit scraping tools?

If you want to scrape specific Reddit data, you can use any of the dedicated scrapers below for faster and more targeted results.

| Scraper Name | Scraper Name |
|---|---|
| [Reddit Api Scraper](https://apify.com/api-empire/reddit-api-scraper) | [Reddit Scraper](https://apify.com/api-empire/reddit-scraper) |
| [Reddit Comment Scraper](https://apify.com/api-empire/reddit-comment-scraper) | [Reddit Subreddit Members Scraper](https://apify.com/api-empire/reddit-subreddit-members-scraper) |
| [Reddit Email Scraper](https://apify.com/api-empire/reddit-email-scraper) | [Reddit Trends Scraper](https://apify.com/api-empire/reddit-trends-scraper) |
| [Reddit Lead Scraper](https://apify.com/api-empire/reddit-lead-scraper) | [Reddit User Profile Posts And Comments Scraper](https://apify.com/api-empire/reddit-user-profile-posts-and-comments-scraper) |
| [Reddit Phone Number Scraper](https://apify.com/api-empire/reddit-phone-number-scraper) |  |

# Actor input Schema

## `startUrls` (type: `array`):

📝 Enter one item per line. You can mix:
• 🌐 Full URLs — e.g. https://www.reddit.com/r/news/
• 📌 Subreddit names — e.g. news or r/news
• 🔍 Search keywords — e.g. artificial intelligence (searches Reddit)

Duplicate subreddits are merged. At least one entry is required.

## `maxPosts` (type: `integer`):

Max number of posts to scrape **per** subreddit or keyword (1–1000). If you have 3 sources and set 50, you can get up to 150 posts total.

## `maxComments` (type: `integer`):

Max comments to fetch for each post (0–1000). Set to **0** to skip comments and only get post metadata (faster).

## `sortOrder` (type: `string`):

How Reddit should sort the posts. Hot = trending now, New = latest first, Top = most upvoted, Rising = gaining traction.

## `timeFilter` (type: `string`):

Time range for results. ⚠️ Only applies when Sort order is **Top** or **Rising**. Ignored for Hot and New.

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

Choose which proxies to use. If Reddit blocks a request, the actor automatically falls back: no proxy → datacenter → residential. ✅ Recommended for large runs or when you hit blocks.

## Actor input object example

```json
{
  "startUrls": [
    "news",
    "r/technology",
    "https://www.reddit.com/r/news/",
    "artificial intelligence"
  ],
  "maxPosts": 20,
  "maxComments": 10,
  "sortOrder": "top",
  "timeFilter": "week",
  "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 = {
    "startUrls": [
        "https://www.reddit.com/r/news/",
        "news",
        "artificial intelligence"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("api-empire/reddit-posts-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 = {
    "startUrls": [
        "https://www.reddit.com/r/news/",
        "news",
        "artificial intelligence",
    ],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("api-empire/reddit-posts-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 '{
  "startUrls": [
    "https://www.reddit.com/r/news/",
    "news",
    "artificial intelligence"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call api-empire/reddit-posts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Posts Scraper",
        "description": "Extract structured Reddit post data at scale. This actor gathers titles, scores, authors, dates, and engagement stats from any subreddit. Ideal for analysts, marketers, and developers who need reliable Reddit insights for monitoring or automation.",
        "version": "0.1",
        "x-build-id": "vcIJiUggI9XxJ5fxy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/api-empire~reddit-posts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-api-empire-reddit-posts-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/api-empire~reddit-posts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-api-empire-reddit-posts-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/api-empire~reddit-posts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-api-empire-reddit-posts-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "🔗 Reddit URLs / Subreddits / Keywords",
                        "type": "array",
                        "description": "📝 Enter one item per line. You can mix:\n• 🌐 Full URLs — e.g. https://www.reddit.com/r/news/\n• 📌 Subreddit names — e.g. news or r/news\n• 🔍 Search keywords — e.g. artificial intelligence (searches Reddit)\n\nDuplicate subreddits are merged. At least one entry is required.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPosts": {
                        "title": "📄 Maximum posts per source",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Max number of posts to scrape **per** subreddit or keyword (1–1000). If you have 3 sources and set 50, you can get up to 150 posts total.",
                        "default": 20
                    },
                    "maxComments": {
                        "title": "💬 Maximum comments per post",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Max comments to fetch for each post (0–1000). Set to **0** to skip comments and only get post metadata (faster).",
                        "default": 10
                    },
                    "sortOrder": {
                        "title": "📋 Sort order",
                        "enum": [
                            "hot",
                            "new",
                            "top",
                            "rising"
                        ],
                        "type": "string",
                        "description": "How Reddit should sort the posts. Hot = trending now, New = latest first, Top = most upvoted, Rising = gaining traction.",
                        "default": "top"
                    },
                    "timeFilter": {
                        "title": "⏱️ Time filter",
                        "enum": [
                            "hour",
                            "day",
                            "week",
                            "month",
                            "year",
                            "all"
                        ],
                        "type": "string",
                        "description": "Time range for results. ⚠️ Only applies when Sort order is **Top** or **Rising**. Ignored for Hot and New.",
                        "default": "week"
                    },
                    "proxyConfiguration": {
                        "title": "🔐 Proxy configuration",
                        "type": "object",
                        "description": "Choose which proxies to use. If Reddit blocks a request, the actor automatically falls back: no proxy → datacenter → residential. ✅ Recommended for large runs or when you hit blocks."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```