# Reddit Scraper (`maximedupre/reddit-scraper`) Actor

The best Reddit scraper, for both posts & comments.

- **URL**: https://apify.com/maximedupre/reddit-scraper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Developer tools, Social media, Automation
- **Stats:** 9 total users, 5 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.30 / 1,000 reddit result rows

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.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

## Find Reddit posts and track conversations around your topic

Reddit Scraper helps you search Reddit for posts and comments about a topic, brand, or trend, so you can find the threads that matter and follow the conversation around them.
Start with the prefilled `Query`, set `Post result cap` plus `Comment result cap` to `2`, and review the first matching conversations in minutes.

- ✅ **Posts and comments together** - find matching threads and comments in one run instead of stitching two searches together.
- ✅ **Conversation-focused query control** - use one `Query` or split into `Advanced posts query` plus `Advanced comments query` when you need tighter search logic.
- ✅ **Useful context stays attached** - keep permalinks, subreddit names, timestamps, votes, and comment text so each match is easy to review.
- ✅ **Tuned default run** - the Input tab prefills `Query` with `openai` and uses validated default caps for a substantial first export under the hosted QA window.
- ✅ **Lightweight source access** - uses Reddit's first-party partial HTML search endpoint with sticky proxy sessions instead of a browser.

⚡️ **[TRY IT FOR FREE](https://console.apify.com/actors/vthjVKfDgKLuS5ZtW?addFromActorId=vthjVKfDgKLuS5ZtW)**

---

### 🏆 Benefits

- 🔎 Turn manual Reddit searching into a repeatable export for monitoring, research, or enrichment.
- 🧾 Keep source links and raw metadata so review, deduping, and downstream storage stay simple.
- 🧠 Tighten Reddit search logic with separate post and comment queries when one broad query is not enough.
- ⚠️ Keep useful rows even when one enabled search pass fails after retries and the other pass still succeeds.

---

### 🚀 Quick start

1. Open the [Input](https://console.apify.com/actors/vthjVKfDgKLuS5ZtW/input) tab and keep `Query` as the prefilled `openai`, or replace it with your Reddit search term.
2. Leave `Include posts?` and `Include comments?` on for the normal mode. Turn one off only when you want a single result type.

> At least one of `Include posts?` or `Include comments?` must stay on.

3. Set `Freshness window (days)` to `7`, then set `Post result cap` and `Comment result cap` to `2` for a quick first run.
4. Leave `Proxy configuration` on the default residential path, run the actor, and review the dataset rows in the finished run or through the API.

---

### ⚙️ Features

- 🔎 Searches Reddit posts and comments in separate passes, so each one can retry and finish independently.
- 🧠 Supports one shared base query or separate advanced overrides for posts and comments.
- 📅 Filters by each result's own Reddit timestamp and returns combined rows newest-first.
- 🔢 Uses per-type caps for cost control, and `0` keeps all available fresh results within the requested window.
- 🌐 Uses Apify residential proxy sessions with sticky rotation.
- 🧾 Emits one normalized row contract for both post and comment results.

---

### 📊 Output

See the full [Output](https://apify.com/maximedupre/reddit-scraper/output-schema) tab for the complete contract.

#### Example

```json
{
	"type": "comment",
	"query": "openai",
	"searchQuery": "openai",
	"url": "https://www.reddit.com/r/accelerate/comments/1shgmq4/_/oftft2k",
	"postId": "1shgmq4",
	"postTitle": "DISCUSSION: Anthropic Has Internal \"Mythos\". OpenAI Has Internal \"Spud\". Elon Says xAI Is Training 6t And 10t Models. What Do You Think Google Has Internally?",
	"postDateTime": "2026-04-10T08:29:05.809Z",
	"subredditName": "accelerate",
	"nbVotes": 1,
	"nbComments": null,
	"commentId": "oftft2k",
	"commenterUsername": "\n    \n     \n    \n       \n    \n  \n    \n      \n        \n          \n        \n      \n      \n    \n    \n  tiger_ace",
	"commentDateTime": "2026-04-12T20:30:00.095Z",
	"commentText": "\n      \n      google doesn't need to rely on hype to survive and i would guess that alphafold probably has already had more impact on science than openai has ever had\n    \n    "
}
````

#### Params

| Field               | Type             | Description                                                           |
| ------------------- | ---------------- | --------------------------------------------------------------------- |
| `type`              | `post / comment` | Whether the row came from the Reddit posts search or comments search. |
| `query`             | `string`         | The base actor input query from `Query`.                              |
| `searchQuery`       | `string`         | The effective query used for this result's search pass.               |
| `url`               | `string`         | Canonical Reddit permalink for the post or comment.                   |
| `postId`            | `string`         | Reddit post ID.                                                       |
| `postTitle`         | `string`         | Post title attached to the result.                                    |
| `postDateTime`      | `string`         | Post timestamp in ISO 8601 format.                                    |
| `subredditName`     | `string`         | Source subreddit name without `r/`.                                   |
| `nbVotes`           | `number`         | Parsed vote count for the post or comment.                            |
| `nbComments`        | `number or null` | Post comment count. Comment rows return `null`.                       |
| `commentId`         | `string or null` | Comment ID. Post rows return `null`.                                  |
| `commenterUsername` | `string or null` | Comment author username. Post rows return `null`.                     |
| `commentDateTime`   | `string or null` | Comment timestamp in ISO 8601 format. Post rows return `null`.        |
| `commentText`       | `string or null` | Raw comment text. Post rows return `null`.                            |

***

### 🛠️ Input

#### Example

```json
{
	"query": "openai",
	"shouldIncludePosts": true,
	"shouldIncludeComments": true,
	"maxDaysOld": 7,
	"maxPostResults": 2,
	"maxCommentResults": 2
}
```

#### Params

| Param                   | Type      | Description                                                                                                                 | Default / empty behavior                                                              |
| ----------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------- |
| `query`                 | `string`  | Base Reddit search query. Use this for normal runs or as the shared label when advanced overrides do the exact search work. | Required. The Input tab prefills it with `openai`.                                    |
| `postsQuery`            | `string`  | Advanced query for Reddit post search only.                                                                                 | Empty reuses `query`.                                                                 |
| `commentsQuery`         | `string`  | Advanced query for Reddit comment search only.                                                                              | Empty reuses `query`.                                                                 |
| `shouldIncludePosts`    | `boolean` | Include Reddit post rows in the dataset.                                                                                    | Defaults to `true`.                                                                   |
| `shouldIncludeComments` | `boolean` | Include Reddit comment rows in the dataset.                                                                                 | Defaults to `true`.                                                                   |
| `maxDaysOld`            | `integer` | Keep only results whose own Reddit timestamp is within this many days.                                                      | Defaults to `30`.                                                                     |
| `maxPostResults`        | `integer` | Cap how many fresh post rows I keep.                                                                                        | Defaults to `150`. Set it to `0` to keep all fresh post results within the window.    |
| `maxCommentResults`     | `integer` | Cap how many fresh comment rows I keep.                                                                                     | Defaults to `150`. Set it to `0` to keep all fresh comment results within the window. |
| `proxyConfiguration`    | `object`  | Proxy settings for Reddit search requests when you want to override the default path.                                       | Defaults to Apify residential proxies with sticky sessions.                           |

#### Important

- 📅 The JSON examples in this README come from a live run on `2026-04-12` with `query: "openai"`, both include toggles on, `maxDaysOld: 7`, and per-type caps of `2`.
- ⚠️ In that same run, the posts search exhausted Reddit verification-challenge retries while the comments search still succeeded and emitted the saved dataset rows.
- 🧠 `Query` stays required even when you use `Advanced posts query` or `Advanced comments query`, because each output row keeps both the base `query` and the effective `searchQuery`.
- 🌐 Leave `Proxy configuration` alone unless you want to override the default residential path for Reddit.

***

### 🔍 Error handling

- ⚠️ Reddit block pages trigger fresh-session retries instead of being treated as empty search results.
- ⚠️ Posts and comments run independently, so one search pass can fail after retries while the other still emits rows in the same run.
- ⚠️ If one result is missing required parsed fields, I log and skip that row while the rest of the pass continues.
- ⚠️ If no fresh results fall inside the requested window, the run finishes successfully with an empty dataset.

***

### Actor Release Notes

- 0.0: Initial release with Reddit post and comment search, advanced query overrides, freshness filtering, and normalized output rows.

***

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/vthjVKfDgKLuS5ZtW/issues) and I'll fix or implement it in less than 24h 🫡

***

### 🔗 Other actors

- [Twitter Scraper](https://apify.com/maximedupre/twitter-scraper) - Search Twitter/X posts with phrase, account, hashtag, and engagement filters.
- [Product Hunt Scraper](https://apify.com/maximedupre/product-hunt-scraper) - Turn Product Hunt launches into lead-ready rows with optional website enrichment.
- [Uneed Scraper](https://apify.com/maximedupre/uneed-scraper) - Collect Uneed launches with maker links, ranks, and optional website emails.
- [Tiny Startups Scraper](https://apify.com/maximedupre/tiny-startups-scraper) - Export Tiny Startups listings with promoted-listing control and optional email enrichment.
- [TinySeed Scraper](https://apify.com/maximedupre/tinyseed-scraper) - Scrape the TinySeed portfolio into company rows with descriptions and optional website emails.
- [Website Emails Scraper](https://apify.com/maximedupre/website-emails-scraper) - Turn any list of websites into one row per discovered contact email.

***

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

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

🔎 Base Reddit search query. Use this for the simple mode, or keep it as the human-readable label while advanced post and comment query overrides do the exact search work.

## `postsQuery` (type: `string`):

🧠 Optional advanced query for Reddit post search only. Leave it empty to reuse Query for posts.

## `commentsQuery` (type: `string`):

🧠 Optional advanced query for Reddit comment search only. Leave it empty to reuse Query for comments.

## `shouldIncludePosts` (type: `boolean`):

📝 Search Reddit posts and include raw post rows in the dataset. Defaults to true.

## `shouldIncludeComments` (type: `boolean`):

💬 Search Reddit comments and include raw comment rows in the dataset. Defaults to true.

## `maxDaysOld` (type: `integer`):

📅 Keep only results whose own Reddit timestamp is within this many days. Defaults to 30.

## `maxPostResults` (type: `integer`):

🔢 Cap how many fresh post rows to return. Defaults to 150. Set it to 0 to keep all available post results within the freshness window.

## `maxCommentResults` (type: `integer`):

🔢 Cap how many fresh comment rows to return. Defaults to 150. Set it to 0 to keep all available comment results within the freshness window.

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

🌐 Apify proxy settings for Reddit search requests. By default the actor uses Apify residential proxies with sticky sessions. Fill this in only when you want to override that default path.

## Actor input object example

```json
{
  "query": "openai",
  "shouldIncludePosts": true,
  "shouldIncludeComments": true,
  "maxDaysOld": 30,
  "maxPostResults": 150,
  "maxCommentResults": 150,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Dataset of raw Reddit search rows

# 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": "openai"
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/reddit-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 = { "query": "openai" }

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/reddit-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 '{
  "query": "openai"
}' |
apify call maximedupre/reddit-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Scraper",
        "description": "The best Reddit scraper, for both posts & comments.",
        "version": "0.0",
        "x-build-id": "scEQBh4pyIhDBVnzo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~reddit-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-reddit-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/maximedupre~reddit-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-reddit-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/maximedupre~reddit-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-reddit-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": [
                    "query"
                ],
                "properties": {
                    "query": {
                        "title": "Query",
                        "minLength": 1,
                        "type": "string",
                        "description": "🔎 Base Reddit search query. Use this for the simple mode, or keep it as the human-readable label while advanced post and comment query overrides do the exact search work."
                    },
                    "postsQuery": {
                        "title": "Advanced posts query",
                        "minLength": 1,
                        "type": "string",
                        "description": "🧠 Optional advanced query for Reddit post search only. Leave it empty to reuse Query for posts."
                    },
                    "commentsQuery": {
                        "title": "Advanced comments query",
                        "minLength": 1,
                        "type": "string",
                        "description": "🧠 Optional advanced query for Reddit comment search only. Leave it empty to reuse Query for comments."
                    },
                    "shouldIncludePosts": {
                        "title": "Include posts?",
                        "type": "boolean",
                        "description": "📝 Search Reddit posts and include raw post rows in the dataset. Defaults to true.",
                        "default": true
                    },
                    "shouldIncludeComments": {
                        "title": "Include comments?",
                        "type": "boolean",
                        "description": "💬 Search Reddit comments and include raw comment rows in the dataset. Defaults to true.",
                        "default": true
                    },
                    "maxDaysOld": {
                        "title": "Freshness window (days)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "📅 Keep only results whose own Reddit timestamp is within this many days. Defaults to 30.",
                        "default": 30
                    },
                    "maxPostResults": {
                        "title": "Post result cap",
                        "minimum": 0,
                        "type": "integer",
                        "description": "🔢 Cap how many fresh post rows to return. Defaults to 150. Set it to 0 to keep all available post results within the freshness window.",
                        "default": 150
                    },
                    "maxCommentResults": {
                        "title": "Comment result cap",
                        "minimum": 0,
                        "type": "integer",
                        "description": "🔢 Cap how many fresh comment rows to return. Defaults to 150. Set it to 0 to keep all available comment results within the freshness window.",
                        "default": 150
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "🌐 Apify proxy settings for Reddit search requests. By default the actor uses Apify residential proxies with sticky sessions. Fill this in only when you want to override that default path.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
