# Reddit Subreddit Posts Scraper (`xtracto/reddit-subreddit-posts-scraper`) Actor

Get posts from any public subreddit by sort (hot/new/top/rising/controversial) and time filter. Bulk-paginated.

- **URL**: https://apify.com/xtracto/reddit-subreddit-posts-scraper.md
- **Developed by:** [Farhan Febrian Nauval](https://apify.com/xtracto) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

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 Subreddit Posts Scraper

Bulk-fetch posts from any public subreddit by sort order — `hot`, `new`, `top`, `rising`, or `controversial` — with optional time-window filtering and pagination.

### Why use this actor

- **No account / no login required** — just give it a list of subreddit names.
- **All five sort modes** — `hot`, `new`, `top`, `rising`, `controversial`, plus a `top` / `controversial` time filter (`hour`, `day`, `week`, `month`, `year`, `all`).
- **Bulk input** — scrape multiple subreddits in a single run; one clean dataset row per post.
- **Anonymous-friendly** — works out of the box without any token; pass an optional Reddit app token for higher rate limits on large jobs.
- **Automatic retries and fallbacks** — transient failures retry with backoff; private / banned subreddits surface as `_error` rows so you can triage failures.
- **Stable JSON output** suitable for pipelines, spreadsheets, and databases — every row carries `_input`, `_source`, `_scrapedAt` envelope fields so you can join results back to your input list.

### How it works

1. You provide a list of subreddit names (e.g. `python`, `r/MachineLearning`) and pick a sort order.
2. The actor walks the subreddit's post listing, paginating until it reaches `maxPosts` or the end of the feed.
3. Each post is normalized into a flat JSON record with title, author, score, comment count, permalink, URL, media, flair, and timestamps.
4. Results stream into your dataset, ready to download as JSON, CSV, or Excel.

You do not need to manage scrapers, browsers, or rotating IPs — all handled internally.

### Input

```json
{
  "subreddits": ["python", "MachineLearning"],
  "sort": "hot",
  "timeFilter": "all",
  "maxPosts": 25,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["DATACENTER"]
  }
}
````

| Field | Type | Description |
|---|---|---|
| `subreddits` | array | Subreddit names to scrape. Accepts plain names (`python`), `r/`-prefixed (`r/python`), or full URLs. |
| `sort` | string | One of `hot`, `new`, `top`, `rising`, `controversial`. Default `hot`. |
| `timeFilter` | string | One of `hour`, `day`, `week`, `month`, `year`, `all`. Only applied when `sort` is `top` or `controversial`. Default `all`. |
| `maxPosts` | integer | Maximum posts per subreddit. `0` = fetch all available (Reddit caps listings at roughly 1,000). Default `25`. |
| `redditClientId` | string | Optional Reddit app token for higher rate limits. Leave blank for anonymous access. |
| `proxyConfiguration` | object | Apify Proxy settings. Datacenter proxy works for most subreddits. |

#### Sort and time-filter reference

| `sort` value | Meaning |
|---|---|
| `hot` | Reddit's front-page algorithm — recent + high-engagement mix. |
| `new` | Strictly chronological, newest first. |
| `top` | Highest-scoring posts within the chosen `timeFilter`. |
| `rising` | Posts gaining engagement velocity right now. |
| `controversial` | Posts with high up/down split within the chosen `timeFilter`. |

| `timeFilter` value | Window |
|---|---|
| `hour` | Last 60 minutes |
| `day` | Last 24 hours |
| `week` | Last 7 days |
| `month` | Last 30 days |
| `year` | Last 365 days |
| `all` | Since the subreddit was created (default) |

### Output

Input: `subreddits: ["AskReddit"]`, `sort: "hot"`, `maxPosts: 3`

```json
[
  {
    "_input": "AskReddit",
    "_source": "S3-fallback",
    "_scrapedAt": "2026-05-18T11:10:22.012033+00:00",
    "id": "1tg56u8",
    "name": "t3_1tg56u8",
    "subreddit": "AskReddit",
    "subreddit_name_prefixed": "r/AskReddit",
    "subreddit_id": "t5_2qh1i",
    "subreddit_subscribers": 58575107,
    "title": "Who destroyed their own career within seconds by being an idiot?",
    "author": "goldbeau",
    "author_fullname": "t2_2dwkdlsms4",
    "ups": 7687,
    "score": 7687,
    "upvote_ratio": 0.95,
    "num_comments": 4941,
    "num_crossposts": 2,
    "permalink": "/r/AskReddit/comments/1tg56u8/who_destroyed_their_own_career_within_seconds_by/",
    "url": "https://old.reddit.com/r/AskReddit/comments/1tg56u8/who_destroyed_their_own_career_within_seconds_by/",
    "domain": "self.AskReddit",
    "is_self": true,
    "is_video": false,
    "thumbnail": "",
    "media": null,
    "link_flair_text": null,
    "over_18": false,
    "spoiler": false,
    "stickied": false,
    "locked": false,
    "archived": false,
    "created_utc": 1779060093.0
  },
  {
    "_input": "AskReddit",
    "_source": "S3-fallback",
    "_scrapedAt": "2026-05-18T11:10:22.012033+00:00",
    "id": "1tg4gql",
    "name": "t3_1tg4gql",
    "subreddit": "AskReddit",
    "title": "What are some lazy jobs that pay a ridiculous amount of money?",
    "author": "Jordz0_0",
    "ups": 2999,
    "score": 2999,
    "upvote_ratio": 0.88,
    "num_comments": 1463,
    "permalink": "/r/AskReddit/comments/1tg4gql/what_are_some_lazy_jobs_that_pay_a_ridiculous/",
    "url": "https://old.reddit.com/r/AskReddit/comments/1tg4gql/what_are_some_lazy_jobs_that_pay_a_ridiculous/",
    "domain": "self.AskReddit",
    "is_self": true,
    "over_18": false,
    "created_utc": 1779058246.0
  }
]
```

#### Output field reference

| Field | Type | Description |
|---|---|---|
| `_input` | string | The subreddit name exactly as you supplied it. Use this to join results back to your input list. |
| `_source` | string | Internal tag for the path used to fetch the record. `S1-primary` = fastest authenticated path (used when you supply `redditClientId`); `S2-fallback` / `S3-fallback` = anonymous public paths used when the primary is unavailable or you didn't pass a token. |
| `_scrapedAt` | string | ISO-8601 UTC timestamp when the record was scraped. |
| `id` | string | Post ID without prefix (e.g. `1tg56u8`). |
| `name` | string | Fully-qualified Reddit ID with `t3_` prefix. |
| `subreddit` | string | Subreddit name (without `r/`). |
| `subreddit_name_prefixed` | string | Subreddit with `r/` prefix. |
| `subreddit_id` | string | Reddit's internal subreddit ID (`t5_` prefix). |
| `subreddit_subscribers` | integer | Subscriber count at scrape time. |
| `title` | string | Post title. |
| `author` | string | Author's Reddit username. |
| `author_fullname` | string | Author's Reddit user ID (`t2_` prefix). |
| `ups` / `score` | integer | Net upvote count. |
| `upvote_ratio` | number | Ratio of upvotes to total votes (0.0–1.0). |
| `num_comments` | integer | Comment count. |
| `num_crossposts` | integer | How many times the post has been crossposted. |
| `permalink` | string | Relative URL to the post on reddit.com. |
| `url` | string | Linked URL — for self-posts this is the Reddit thread; for link posts this is the external URL. |
| `domain` | string | Domain of `url` (e.g. `self.AskReddit`, `github.com`). |
| `is_self` | boolean | `true` if the post is a text post, `false` for link / image / video posts. |
| `is_video` | boolean | `true` if the post is a Reddit-hosted video. |
| `thumbnail` | string | Thumbnail image URL (empty string for self-posts). |
| `media` | object | Embedded media metadata when present (video, gallery, etc.); `null` for text / link posts. |
| `link_flair_text` | string | Post flair text, or `null` if no flair is set. |
| `over_18` | boolean | NSFW flag — posts marked NSFW are returned with `over_18: true`. |
| `spoiler` | boolean | `true` if the post is marked as a spoiler. |
| `stickied` | boolean | `true` if the post is pinned to the top of the subreddit. |
| `locked` | boolean | `true` if comments are locked. |
| `archived` | boolean | `true` if the post is older than 6 months and no longer editable. |
| `created_utc` | number | Post creation time as a Unix timestamp (seconds). |

#### Error envelope

Subreddits that don't exist, are private, banned, or fail to fetch return a structured error instead of crashing the run:

```json
{
  "_input": "this-subreddit-does-not-exist-xyz",
  "_source": "S2-fallback",
  "_scrapedAt": "2026-05-18T11:10:22.012033+00:00",
  "_error": "fetch_failed",
  "_errorDetail": "NotFound https://www.reddit.com/r/this-subreddit-does-not-exist-xyz/hot.json"
}
```

Filter on `_error` to triage failed rows.

### Pricing

This actor is billed per result: **$3.50 per 1,000 posts**. Each successful post = 1 result. Error rows (private / banned / not-found subreddits) are not billed.

### Other Sosmed Actors

| Platform | Actor | Best for |
|---|---|---|
| Reddit | [Reddit User Profile Scraper](https://apify.com/xtracto/reddit-user-profile-scraper) | Karma, account age, trophies for any Reddit user |
| Reddit | [Reddit Search Scraper](https://apify.com/xtracto/reddit-search-scraper) | Keyword search globally or within a single subreddit |
| Reddit | [Reddit Post Detail Scraper](https://apify.com/xtracto/reddit-post-detail-scraper) | Single post + full nested comments tree |
| YouTube | [YouTube Channel Scraper](https://apify.com/xtracto/youtube-channel-scraper) | Recent uploads, view counts, and channel metadata |
| Bluesky | [Bluesky Search Scraper](https://apify.com/xtracto/bluesky-search-scraper) | Keyword search across the atproto network |
| Telegram | [Telegram Channel Posts Scraper](https://apify.com/xtracto/telegram-channel-posts-scraper) | Public Telegram channel post history |
| Mastodon | [Mastodon Account Scraper](https://apify.com/xtracto/mastodon-account-scraper) | Profile + toot history for any Mastodon handle |

Browse the full catalog at [apify.com/xtracto](https://apify.com/xtracto).

### Notes

- Private, banned, or quarantined subreddits return `{"_error": "fetch_failed", ...}` rather than partial data — filter on `_error` to triage.
- NSFW posts are returned with `over_18: true` set; filter them client-side if you need a SFW-only dataset.
- For jobs larger than ~1,000 posts per subreddit, register a free Reddit app at [reddit.com/prefs/apps](https://www.reddit.com/prefs/apps) and pass `redditClientId` — anonymous access is rate-limited and large bulk runs will be noticeably slower without a token.
- Reddit listings are capped at roughly 1,000 posts per sort regardless of `maxPosts`; for deeper history use the companion [Reddit Search Scraper](https://apify.com/xtracto/reddit-search-scraper) with date filters.
- Need a single post with its full comments tree? Use [Reddit Post Detail Scraper](https://apify.com/xtracto/reddit-post-detail-scraper). Need a user's submission history? Use [Reddit User Profile Scraper](https://apify.com/xtracto/reddit-user-profile-scraper).

# Actor input Schema

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

Subreddit names to scrape. Accepts plain names (e.g. `python`), `r/`-prefixed (`r/python`), or full URLs.

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

How to sort the subreddit feed. `hot` = front-page algorithm, `new` = chronological, `top` / `controversial` = ranked within the time window, `rising` = trending now.

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

Time window applied when `sort` is `top` or `controversial`. Ignored for other sorts.

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

Maximum posts returned per subreddit. Set to `0` to fetch all available posts (Reddit caps listings at roughly 1,000).

## `redditClientId` (type: `string`):

Optional Reddit app client ID for higher rate limits. Without it, the actor uses public anonymous access. Get one free at reddit.com/prefs/apps.

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

Apify Proxy settings. A Residential proxy is required — Reddit blocks datacenter addresses, so datacenter runs return no data. This is prefilled for you.

## Actor input object example

```json
{
  "subreddits": [
    "python",
    "MachineLearning"
  ],
  "sort": "hot",
  "timeFilter": "all",
  "maxPosts": 25,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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": [
        "python",
        "MachineLearning"
    ],
    "sort": "hot",
    "timeFilter": "all",
    "maxPosts": 25
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "subreddits": [
        "python",
        "MachineLearning",
    ],
    "sort": "hot",
    "timeFilter": "all",
    "maxPosts": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("xtracto/reddit-subreddit-posts-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "subreddits": [
    "python",
    "MachineLearning"
  ],
  "sort": "hot",
  "timeFilter": "all",
  "maxPosts": 25
}' |
apify call xtracto/reddit-subreddit-posts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Subreddit Posts Scraper",
        "description": "Get posts from any public subreddit by sort (hot/new/top/rising/controversial) and time filter. Bulk-paginated.",
        "version": "1.0",
        "x-build-id": "jLconvsgairgWj2z1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/xtracto~reddit-subreddit-posts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-xtracto-reddit-subreddit-posts-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/xtracto~reddit-subreddit-posts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-xtracto-reddit-subreddit-posts-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/xtracto~reddit-subreddit-posts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-xtracto-reddit-subreddit-posts-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "subreddits"
                ],
                "properties": {
                    "subreddits": {
                        "title": "Subreddits",
                        "type": "array",
                        "description": "Subreddit names to scrape. Accepts plain names (e.g. `python`), `r/`-prefixed (`r/python`), or full URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "hot",
                            "new",
                            "top",
                            "rising",
                            "controversial"
                        ],
                        "type": "string",
                        "description": "How to sort the subreddit feed. `hot` = front-page algorithm, `new` = chronological, `top` / `controversial` = ranked within the time window, `rising` = trending now.",
                        "default": "hot"
                    },
                    "timeFilter": {
                        "title": "Time window (top / controversial only)",
                        "enum": [
                            "hour",
                            "day",
                            "week",
                            "month",
                            "year",
                            "all"
                        ],
                        "type": "string",
                        "description": "Time window applied when `sort` is `top` or `controversial`. Ignored for other sorts.",
                        "default": "all"
                    },
                    "maxPosts": {
                        "title": "Max posts per subreddit",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum posts returned per subreddit. Set to `0` to fetch all available posts (Reddit caps listings at roughly 1,000).",
                        "default": 25
                    },
                    "redditClientId": {
                        "title": "Reddit app token (optional)",
                        "type": "string",
                        "description": "Optional Reddit app client ID for higher rate limits. Without it, the actor uses public anonymous access. Get one free at reddit.com/prefs/apps."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy settings. A Residential proxy is required — Reddit blocks datacenter addresses, so datacenter runs return no data. This is prefilled for you.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
