# Reddit Post Monitor Lite (`fetch_cat/reddit-post-monitor-lite`) Actor

Monitor Reddit posts from subreddits or searches and export post data for alerts, analysis, and AI agents.

- **URL**: https://apify.com/fetch\_cat/reddit-post-monitor-lite.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 post saveds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Reddit Post Monitor Lite

Monitor new Reddit posts from subreddits, Reddit search queries, or Reddit listing URLs. The actor returns clean post records that are ready for alerts, lead discovery, trend tracking, research dashboards, and AI agents.

### What you can do with this actor

- Track new posts in one or more subreddits.
- Watch Reddit searches for keywords, brands, competitors, jobs, products, or support topics.
- Export post metadata such as title, author, subreddit, score, comments, flair, links, media URLs, safety flags, and timestamps.
- Feed fresh Reddit discussions into automation workflows, MCP-compatible clients, or LLM analysis.

### Who is it for?

- Growth and social listening teams monitoring brand mentions.
- Researchers tracking community discussions and trends.
- Support teams watching Reddit for bug reports and complaints.
- Builders who need Reddit post data in Apify datasets, APIs, or agents.

### Ready-to-run examples

#### Monitor subreddit posts

```json
{
  "subreddits": ["apify", "webscraping"],
  "maxPosts": 25,
  "sort": "new",
  "includeNsfw": false,
  "useApifyProxy": true
}
````

#### Monitor Reddit search terms

```json
{
  "searchQueries": ["apify actor", "web scraping API"],
  "maxPosts": 50,
  "sort": "new",
  "timeFilter": "week",
  "useApifyProxy": true
}
```

### Input

| Field | Type | Description |
| --- | --- | --- |
| `subreddits` | array | Subreddit names without `r/`, for example `apify` or `webscraping`. |
| `searchQueries` | array | Reddit search queries to monitor. |
| `redditUrls` | array | Optional Reddit listing URLs. |
| `maxPosts` | integer | Maximum number of posts to save across all sources. |
| `sort` | string | Sort order: `new`, `hot`, `top`, `rising`, `comments`, or `relevance`. |
| `timeFilter` | string | Time window for top/search sorts. |
| `minScore` | integer | Optional minimum score/upvote threshold. |
| `maxScore` | integer | Optional maximum score/upvote threshold. |
| `minComments` | integer | Optional minimum comment count. |
| `flairFilter` | string | Optional exact flair text filter. |
| `domainFilter` | string | Optional domain contains filter for link posts. |
| `authorFilter` | string | Optional Reddit username filter. |
| `includeNsfw` | boolean | Include posts marked as NSFW. |
| `useApifyProxy` | boolean | Use Apify Proxy for Reddit requests. |
| `proxyGroups` | array | Optional Apify Proxy groups. |

Provide at least one subreddit, search query, or Reddit URL.

### Output

Each dataset item represents one Reddit post.

```json
{
  "postId": "abc123",
  "name": "t3_abc123",
  "subreddit": "apify",
  "postTitle": "Example Reddit post title",
  "author": "example_user",
  "url": "https://www.reddit.com/r/apify/comments/abc123/example/",
  "permalink": "https://www.reddit.com/r/apify/comments/abc123/example/",
  "createdAt": "2026-07-07T00:00:00.000Z",
  "score": 42,
  "upvoteRatio": 0.95,
  "numComments": 7,
  "over18": false,
  "isSelf": true,
  "selftext": "Post body text when available",
  "linkUrl": null,
  "flair": "Discussion",
  "domain": "self.apify",
  "thumbnail": null,
  "dataType": "post",
  "postType": "text",
  "contentHtml": "<div class=\"md\"><p>Post body text when available</p></div>",
  "authorId": "t2_example",
  "authorFlair": null,
  "subredditId": "t5_example",
  "subredditSubscribers": 12345,
  "spoiler": false,
  "stickied": false,
  "locked": false,
  "archived": false,
  "isVideo": false,
  "isGallery": false,
  "galleryCount": 0,
  "mediaUrls": [],
  "awards": 0,
  "scorePerHour": 1.23,
  "commentsPerHour": 0.2,
  "engagementTotal": 49,
  "sourceType": "subreddit",
  "source": "apify",
  "fetchedAt": "2026-07-07T00:01:00.000Z"
}
```

### Pricing

This actor uses pay-per-event pricing:

- Start event: `$0.005` per run.
- Post saved event: tiered from `$0.00115` to `$0.00028` per saved post depending on your Apify plan tier.

You only pay per post saved to the dataset, plus the small start event.

### API usage

Run the actor with the Apify API from cURL, Node.js, or Python.

#### cURL

```bash
curl "https://api.apify.com/v2/acts/fetch_cat/reddit-post-monitor-lite/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"subreddits":["apify"],"maxPosts":25,"useApifyProxy":true}'
```

#### Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/reddit-post-monitor-lite').call({
  subreddits: ['apify'],
  maxPosts: 10,
  useApifyProxy: true
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('fetch_cat/reddit-post-monitor-lite').call(run_input={
    'subreddits': ['apify'],
    'maxPosts': 10,
    'useApifyProxy': True,
})
print(run['defaultDatasetId'])
```

After a run finishes, download results from the default dataset URL shown in the run details.

### MCP and AI agents

Use this actor from MCP-compatible clients with:

```text
https://mcp.apify.com/?tools=fetch_cat/reddit-post-monitor-lite
```

Add it to Claude Code:

```bash
claude mcp add apify-reddit-post-monitor --transport http https://mcp.apify.com/?tools=fetch_cat/reddit-post-monitor-lite
```

MCP JSON configuration:

```json
{
  "mcpServers": {
    "apify-reddit-post-monitor": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/reddit-post-monitor-lite"
    }
  }
}
```

Example prompts:

- "Monitor r/apify and summarize the newest posts."
- "Find recent Reddit posts mentioning Apify actors and group them by topic."
- "Export posts from r/webscraping and identify questions that need replies."

The clean dataset output is suitable for summarization, alert generation, topic clustering, and agent workflows.

### Limits and tips

- Reddit may rate-limit or block direct requests. Keep `useApifyProxy` enabled for the most reliable runs.
- Use low `maxPosts` values for frequent monitoring and scheduled runs.
- Duplicate posts from overlapping sources are deduplicated within a single run.
- NSFW posts are skipped unless `includeNsfw` is enabled.

### Legality

This actor is designed for publicly available Reddit content. Use it responsibly, respect privacy, and make sure your use case complies with Reddit's terms, Apify's terms, and applicable laws.

### FAQ

**Can I monitor multiple subreddits?** Yes. Add several names to `subreddits` and set a shared `maxPosts` limit.

**Can I search Reddit by keyword?** Yes. Use `searchQueries` for keywords, brands, or phrases.

**Why did my run return few posts?** Reddit availability, filters, and rate limits can affect results. Try a broader query, another sort, or a larger `maxPosts` value.

### Related actors

- [Reddit Scraper](https://apify.com/fetch_cat/reddit-scraper) - broader Reddit scraping workflows.
- [X Profile Tweets Scraper](https://apify.com/fetch_cat/x-profile-tweets-scraper) - monitor X/Twitter profile content.
- [Hacker News Search Scraper](https://apify.com/fetch_cat/hacker-news-search-scraper) - track Hacker News discussions.

### Support

If results look wrong, open an issue from the actor page and include the run ID, run URL, input JSON, expected output, and actual output.

### Changelog

- 0.1 - Initial Reddit post monitoring build.

# Actor input Schema

## `subreddits` (type: `array`):

Subreddit names to monitor, without r/. Example: apify, webscraping, MachineLearning.

## `searchQueries` (type: `array`):

Optional Reddit search queries to monitor in addition to subreddit feeds.

## `redditUrls` (type: `array`):

Optional Reddit listing URLs, such as subreddit, search, or comments pages.

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

Maximum number of posts to save across all sources.

## `sort` (type: `string`):

Sort to use for subreddit and search sources.

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

Time window for top/search sorts that support it.

## `minScore` (type: `integer`):

Only save posts with at least this many upvotes/score. Leave empty to keep all scores.

## `maxScore` (type: `integer`):

Only save posts with at most this many upvotes/score. Leave empty for no upper limit.

## `minComments` (type: `integer`):

Only save posts with at least this many comments. Leave empty to keep all posts.

## `flairFilter` (type: `string`):

Only save posts whose flair text exactly matches this value (case-insensitive).

## `domainFilter` (type: `string`):

Only save link posts whose domain contains this text, for example youtube.com or github.com.

## `authorFilter` (type: `string`):

Only save posts by this Reddit username. You can include or omit the u/ prefix.

## `includeNsfw` (type: `boolean`):

Keep posts marked over\_18 in the output.

## `useApifyProxy` (type: `boolean`):

Enable Apify Proxy for Reddit requests. Useful when Reddit blocks direct data center traffic.

## `proxyGroups` (type: `array`):

Optional Apify Proxy groups. Leave empty to use automatic proxy selection.

## Actor input object example

```json
{
  "subreddits": [
    "apify",
    "webscraping"
  ],
  "searchQueries": [
    "apify actor"
  ],
  "redditUrls": [],
  "maxPosts": 10,
  "sort": "new",
  "timeFilter": "week",
  "includeNsfw": false,
  "useApifyProxy": true,
  "proxyGroups": []
}
```

# Actor output Schema

## `overview` (type: `string`):

Open the default dataset in the overview table view to review saved Reddit posts with title, subreddit, author, score, comments, links, media indicators, and source details.

# 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 = {
    "subreddits": [
        "apify",
        "webscraping"
    ],
    "searchQueries": [
        "apify actor"
    ],
    "redditUrls": [],
    "proxyGroups": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/reddit-post-monitor-lite").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 = {
    "subreddits": [
        "apify",
        "webscraping",
    ],
    "searchQueries": ["apify actor"],
    "redditUrls": [],
    "proxyGroups": [],
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/reddit-post-monitor-lite").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 '{
  "subreddits": [
    "apify",
    "webscraping"
  ],
  "searchQueries": [
    "apify actor"
  ],
  "redditUrls": [],
  "proxyGroups": []
}' |
apify call fetch_cat/reddit-post-monitor-lite --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Post Monitor Lite",
        "description": "Monitor Reddit posts from subreddits or searches and export post data for alerts, analysis, and AI agents.",
        "version": "0.1",
        "x-build-id": "yARj5nBzCREvMTEEk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~reddit-post-monitor-lite/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-reddit-post-monitor-lite",
                "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/fetch_cat~reddit-post-monitor-lite/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-reddit-post-monitor-lite",
                "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/fetch_cat~reddit-post-monitor-lite/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-reddit-post-monitor-lite",
                "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",
                "properties": {
                    "subreddits": {
                        "title": "Subreddits",
                        "type": "array",
                        "description": "Subreddit names to monitor, without r/. Example: apify, webscraping, MachineLearning.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Optional Reddit search queries to monitor in addition to subreddit feeds.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "redditUrls": {
                        "title": "Reddit URLs",
                        "type": "array",
                        "description": "Optional Reddit listing URLs, such as subreddit, search, or comments pages.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxPosts": {
                        "title": "Maximum posts",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of posts to save across all sources.",
                        "default": 10
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "new",
                            "hot",
                            "top",
                            "rising",
                            "comments",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "Sort to use for subreddit and search sources.",
                        "default": "new"
                    },
                    "timeFilter": {
                        "title": "Time filter",
                        "enum": [
                            "hour",
                            "day",
                            "week",
                            "month",
                            "year",
                            "all"
                        ],
                        "type": "string",
                        "description": "Time window for top/search sorts that support it.",
                        "default": "week"
                    },
                    "minScore": {
                        "title": "Minimum score",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only save posts with at least this many upvotes/score. Leave empty to keep all scores."
                    },
                    "maxScore": {
                        "title": "Maximum score",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only save posts with at most this many upvotes/score. Leave empty for no upper limit."
                    },
                    "minComments": {
                        "title": "Minimum comments",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only save posts with at least this many comments. Leave empty to keep all posts."
                    },
                    "flairFilter": {
                        "title": "Exact flair filter",
                        "type": "string",
                        "description": "Only save posts whose flair text exactly matches this value (case-insensitive)."
                    },
                    "domainFilter": {
                        "title": "Domain contains filter",
                        "type": "string",
                        "description": "Only save link posts whose domain contains this text, for example youtube.com or github.com."
                    },
                    "authorFilter": {
                        "title": "Author filter",
                        "type": "string",
                        "description": "Only save posts by this Reddit username. You can include or omit the u/ prefix."
                    },
                    "includeNsfw": {
                        "title": "Include NSFW posts",
                        "type": "boolean",
                        "description": "Keep posts marked over_18 in the output.",
                        "default": false
                    },
                    "useApifyProxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "Enable Apify Proxy for Reddit requests. Useful when Reddit blocks direct data center traffic.",
                        "default": true
                    },
                    "proxyGroups": {
                        "title": "Proxy groups",
                        "type": "array",
                        "description": "Optional Apify Proxy groups. Leave empty to use automatic proxy selection.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```