# Reddit Data Engine for Claude (MCP) (`practicaltools/reddit-claude-connector`) Actor

The dedicated data Actor behind the Reddit Research Claude connector. Search Reddit,
browse subreddits, pull posts with comments, and look up user profiles, reserved
capacity so Claude's requests never queue behind bulk scraping jobs.

- **URL**: https://apify.com/practicaltools/reddit-claude-connector.md
- **Developed by:** [Practical Tools](https://apify.com/practicaltools) (community)
- **Categories:** AI, Social media, MCP servers
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 item prices

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 Research for Claude — MCP Connector Actor

practicaltools/reddit-claude-connector


This Actor is the dedicated data engine behind the
[Reddit Research Claude connector](https://redditmcp.practical.tools) — an MCP server
that lets Claude search Reddit, browse subreddits, read posts with comments, and look
up user profiles, using Reddit's official OAuth2 API (no end-user login required).

⚠️ **Looking for the cheapest bulk option instead?** This Actor is reserved for
Claude/agent traffic and priced accordingly. For raw bulk data at the lowest price,
use [Fast Reddit Scraper ($2/1k)](https://apify.com/practicaltools/apify-reddit-api).
For deduplicated lead-gen monitoring, use
[Reddit Keyword Monitor](https://apify.com/practicaltools/reddit-keyword-monitor).

### Why a dedicated Actor for Claude?

Claude connectors need to feel instant — a user asks a question, Claude calls a tool,
and the answer needs to come back inside a single conversational turn. Sharing infra
with high-volume bulk scraping jobs means Claude's requests can end up queued behind
someone else's 50,000-item run.

This Actor exists to avoid that. It runs on capacity reserved for interactive,
agent-driven traffic, kept in lockstep with the
[Reddit Research connector's](https://redditmcp.practical.tools) four tools
(`search_reddit`, `get_subreddit_posts`, `get_post_with_comments`, `get_user_profile`).
Same underlying data and Reddit API access as our other Reddit Actors — the premium
buys reliability and priority, not different data.

### What does this Actor do?

- Scrape subreddits (communities) and get top/new/hot posts
- Extract Reddit posts with title, text, username, number of comments, votes, and media
- Get Reddit comments, timestamps, points, usernames, post and comment URLs
- Scrape user details, their most recent posts, and comments
- Sort scraped data by Relevance, Hot, Top, or New
- Scrape by specific Reddit URLs or by keyword search

### What data can you extract?

- Subreddit details: name, number of members, description, URL
- Reddit posts: title, text, username, votes, media, timestamps
- Reddit comments: body, username, upvotes, timestamps, parent/post info
- User details: profile info, karma, recent posts/comments

### Use it via Claude (recommended)

Most people using this Actor won't call it directly — they'll talk to Claude. Add the
connector once, and Claude handles the rest:

1. In Claude: **Settings → Connectors → Add custom connector**
2. Enter `https://redditmcp.practical.tools/mcp`
3. Paste an Apify API token when prompted (this Actor bills to that token)
4. Ask Claude to research something on Reddit

Full setup docs: [redditmcp.practical.tools](https://redditmcp.practical.tools)

### Using the Actor directly

The Actor also works standalone via the Apify console, API, or CLI, with the same
input schema as our other Reddit Actors.

#### Mode 1: Start URLs (direct scraping)

| URL type | What you get |
| --- | --- |
| `reddit.com/r/python/` | Posts from the subreddit feed + optional community metadata |
| `reddit.com/r/python/comments/abc123/` | That specific post + its comments (with nested replies) |
| `reddit.com/user/someuser/` | User profile + their recent posts |

#### Mode 2: Search Queries

Provide one or more search queries. Each runs independently and searches all of Reddit
by default. Use the search type flags (`searchPosts`, `searchComments`,
`searchCommunities`, `searchUsers`) to control what kinds of results come back. Combine
with a subreddit URL in Start URLs to scope a search to one community instead of all
of Reddit.

#### Example inputs

**Scrape a subreddit feed:**
\`\`\`json
{
  "startUrls": [{ "url": "https://www.reddit.com/r/javascript/" }],
  "sort": "hot",
  "maxItems": 50,
  "skipCommunity": true
}
\`\`\`

**Search for posts and their comments:**
\`\`\`json
{
  "searches": ["web scraping"],
  "searchPosts": true,
  "searchComments": true,
  "fetchPostComments": true,
  "sort": "relevance",
  "time": "month",
  "maxItems": 25
}
\`\`\`

### Pricing

**$8.00 per 1,000 results** — posts, comments, users, or communities returned.
Apify's free plan gives every account $5/month of platform credit — **625 results,
free, every month** — so you can fully test the Claude connector before spending
anything.

- No per-run or start fees — you're charged only for what you get back
- Costs scale linearly: 500 results = $4.00, 2,000 results = $16.00
- Priced above our bulk Actor deliberately — this pays for capacity reserved for
  real-time, interactive traffic instead of competing with bulk jobs for the same
  queue

If you're running large one-off bulk exports rather than powering an AI agent, use
[Fast Reddit Scraper ($2/1k)](https://apify.com/practicaltools/apify-reddit-api)
instead — same data, lower price, no reserved-capacity guarantee.

### FAQ

**Is Reddit scraping legal?** Scraping public Reddit data is generally allowed, but
always comply with Reddit's terms of service and use data responsibly.

**Do I need proxies?** No — this uses Reddit's official OAuth2 API, not scraping.

**Why is this pricier than your other Reddit Actor?** It's the same data and the same
underlying API access, running on infrastructure reserved for low-latency, interactive
use — specifically the [Claude connector](https://redditmcp.practical.tools). If price
matters more than latency/reliability guarantees to you, use our other Reddit Actors
instead.

**Can I use this without Claude?** Yes, directly via the Apify console, API, or CLI —
see "Using the Actor directly" above.
\`\`\`

# Actor input Schema

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

Reddit URLs to scrape directly. Supports three URL types:
• Subreddit (e.g. reddit.com/r/python/) — scrapes the subreddit feed
• Post (e.g. reddit.com/r/python/comments/abc123/) — fetches that post and its comments
• User (e.g. reddit.com/user/someuser/) — fetches the user profile and their recent posts

Tip: combine with Search Queries to search within a specific subreddit instead of globally.
## `searches` (type: `array`):

Keywords or phrases to search for on Reddit. Each query runs independently and returns up to Max Items results.

Tip: wrap a query in quotes for exact phrase matching — e.g. '"web scraping"' will only match that exact phrase, while 'web scraping' matches posts containing both words anywhere.

What gets searched depends on the search type flags below. If you also provide a subreddit in Start URLs, the search is scoped to that subreddit. Otherwise it searches all of Reddit.
## `sort` (type: `string`):

How to order results.

For search queries: relevance (default) gives the best matches; new/top/hot/comments also work.
For subreddit feeds: hot/new/top/controversial/rising. If you pick 'relevance' with a subreddit feed, it falls back to hot.

relevance and comments are only valid for searches, not subreddit feeds.
## `time` (type: `string`):

Limits results to posts created within the selected time window. Applies to both subreddit feeds and search queries. Use 'all' to include posts from any time.
## `maxItems` (type: `integer`):

Maximum number of results per job. Each search query, subreddit, or URL counts as a separate job, so total output can exceed this number when you have multiple inputs.

Example: 2 search queries × maxItems 25 = up to 50 posts total.
## `includeNSFW` (type: `boolean`):

Include NSFW (Not Safe For Work) content.
## `skipComments` (type: `boolean`):

When scraping a direct post URL, comments are fetched by default. Enable this to get only the post metadata without its comments. Does not affect the 'Fetch Comments for Each Post' option.
## `skipUserPosts` (type: `boolean`):

When scraping a user profile, recent posts are fetched by default alongside profile info. Enable this to get only the profile metadata.
## `skipCommunity` (type: `boolean`):

When scraping a subreddit feed, community metadata (member count, description, etc.) is fetched alongside posts. Enable this to skip that extra request and get only posts.
## `ignorestartUrls` (type: `boolean`):

Forces search-only mode — Start URLs are ignored even if provided. Useful if you have URLs saved in your input but want to run a search-only job without deleting them.
## `searchPosts` (type: `boolean`):

Find posts matching the search keyword. Returns post objects with title, body, upvotes, and comment count. On by default — disable if you only want comments, communities, or users.
## `searchComments` (type: `boolean`):

Find comments matching the search keyword. Works by fetching posts that match the keyword and then filtering their comments — this uses more API calls than post search.
## `fetchPostComments` (type: `boolean`):

When enabled, each post returned from a subreddit or keyword search will include a 'comments' array with its top-level comments. Significantly increases API usage — one extra request per post.
## `searchCommunities` (type: `boolean`):

Find subreddits whose name or description matches the keyword. Returns community objects with member count, description, and URL.
## `searchUsers` (type: `boolean`):

Find Reddit user accounts matching the keyword. Returns user objects with karma, profile info, and account age.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.reddit.com/r/javascript/"
    }
  ],
  "searches": [
    "apify"
  ],
  "sort": "relevance",
  "time": "all",
  "maxItems": 25,
  "includeNSFW": false,
  "skipComments": false,
  "skipUserPosts": false,
  "skipCommunity": true,
  "ignorestartUrls": false,
  "searchPosts": true,
  "searchComments": false,
  "fetchPostComments": false,
  "searchCommunities": false,
  "searchUsers": 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": [
        {
            "url": "https://www.reddit.com/r/javascript/"
        }
    ],
    "searches": [
        "apify"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("practicaltools/reddit-claude-connector").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": [{ "url": "https://www.reddit.com/r/javascript/" }],
    "searches": ["apify"],
}

# Run the Actor and wait for it to finish
run = client.actor("practicaltools/reddit-claude-connector").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": [
    {
      "url": "https://www.reddit.com/r/javascript/"
    }
  ],
  "searches": [
    "apify"
  ]
}' |
apify call practicaltools/reddit-claude-connector --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Data Engine for Claude (MCP)",
        "description": "The dedicated data Actor behind the Reddit Research Claude connector. Search Reddit,\nbrowse subreddits, pull posts with comments, and look up user profiles, reserved\ncapacity so Claude's requests never queue behind bulk scraping jobs.",
        "version": "0.0",
        "x-build-id": "TkvpbT22T3UN1CcH3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/practicaltools~reddit-claude-connector/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-practicaltools-reddit-claude-connector",
                "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/practicaltools~reddit-claude-connector/runs": {
            "post": {
                "operationId": "runs-sync-practicaltools-reddit-claude-connector",
                "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/practicaltools~reddit-claude-connector/run-sync": {
            "post": {
                "operationId": "run-sync-practicaltools-reddit-claude-connector",
                "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": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Reddit URLs to scrape directly. Supports three URL types:\n• Subreddit (e.g. reddit.com/r/python/) — scrapes the subreddit feed\n• Post (e.g. reddit.com/r/python/comments/abc123/) — fetches that post and its comments\n• User (e.g. reddit.com/user/someuser/) — fetches the user profile and their recent posts\n\nTip: combine with Search Queries to search within a specific subreddit instead of globally.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL",
                                    "pattern": "^(https?:\\/\\/)?(www\\.)?reddit\\.com\\/.+$",
                                    "description": "A valid Reddit URL."
                                }
                            },
                            "required": [
                                "url"
                            ]
                        }
                    },
                    "searches": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "Keywords or phrases to search for on Reddit. Each query runs independently and returns up to Max Items results.\n\nTip: wrap a query in quotes for exact phrase matching — e.g. '\"web scraping\"' will only match that exact phrase, while 'web scraping' matches posts containing both words anywhere.\n\nWhat gets searched depends on the search type flags below. If you also provide a subreddit in Start URLs, the search is scoped to that subreddit. Otherwise it searches all of Reddit.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sort": {
                        "title": "Sort By",
                        "enum": [
                            "relevance",
                            "hot",
                            "new",
                            "top",
                            "comments",
                            "controversial",
                            "rising"
                        ],
                        "type": "string",
                        "description": "How to order results.\n\nFor search queries: relevance (default) gives the best matches; new/top/hot/comments also work.\nFor subreddit feeds: hot/new/top/controversial/rising. If you pick 'relevance' with a subreddit feed, it falls back to hot.\n\nrelevance and comments are only valid for searches, not subreddit feeds.",
                        "default": "relevance"
                    },
                    "time": {
                        "title": "Time Filter",
                        "enum": [
                            "all",
                            "day",
                            "hour",
                            "month",
                            "week",
                            "year"
                        ],
                        "type": "string",
                        "description": "Limits results to posts created within the selected time window. Applies to both subreddit feeds and search queries. Use 'all' to include posts from any time.",
                        "default": "all"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of results per job. Each search query, subreddit, or URL counts as a separate job, so total output can exceed this number when you have multiple inputs.\n\nExample: 2 search queries × maxItems 25 = up to 50 posts total.",
                        "default": 25
                    },
                    "includeNSFW": {
                        "title": "Include NSFW",
                        "type": "boolean",
                        "description": "Include NSFW (Not Safe For Work) content.",
                        "default": false
                    },
                    "skipComments": {
                        "title": "Skip Comments (for direct post URLs)",
                        "type": "boolean",
                        "description": "When scraping a direct post URL, comments are fetched by default. Enable this to get only the post metadata without its comments. Does not affect the 'Fetch Comments for Each Post' option.",
                        "default": false
                    },
                    "skipUserPosts": {
                        "title": "Skip User Posts",
                        "type": "boolean",
                        "description": "When scraping a user profile, recent posts are fetched by default alongside profile info. Enable this to get only the profile metadata.",
                        "default": false
                    },
                    "skipCommunity": {
                        "title": "Skip Community Info",
                        "type": "boolean",
                        "description": "When scraping a subreddit feed, community metadata (member count, description, etc.) is fetched alongside posts. Enable this to skip that extra request and get only posts.",
                        "default": true
                    },
                    "ignorestartUrls": {
                        "title": "Ignore Start URLs",
                        "type": "boolean",
                        "description": "Forces search-only mode — Start URLs are ignored even if provided. Useful if you have URLs saved in your input but want to run a search-only job without deleting them.",
                        "default": false
                    },
                    "searchPosts": {
                        "title": "Search Posts",
                        "type": "boolean",
                        "description": "Find posts matching the search keyword. Returns post objects with title, body, upvotes, and comment count. On by default — disable if you only want comments, communities, or users.",
                        "default": true
                    },
                    "searchComments": {
                        "title": "Search Comments",
                        "type": "boolean",
                        "description": "Find comments matching the search keyword. Works by fetching posts that match the keyword and then filtering their comments — this uses more API calls than post search.",
                        "default": false
                    },
                    "fetchPostComments": {
                        "title": "Fetch Comments for Each Post",
                        "type": "boolean",
                        "description": "When enabled, each post returned from a subreddit or keyword search will include a 'comments' array with its top-level comments. Significantly increases API usage — one extra request per post.",
                        "default": false
                    },
                    "searchCommunities": {
                        "title": "Search Communities",
                        "type": "boolean",
                        "description": "Find subreddits whose name or description matches the keyword. Returns community objects with member count, description, and URL.",
                        "default": false
                    },
                    "searchUsers": {
                        "title": "Search Users",
                        "type": "boolean",
                        "description": "Find Reddit user accounts matching the keyword. Returns user objects with karma, profile info, and account age.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```