# Reddit Trends Scraper (`khadinakbar/reddit-trends-scraper`) Actor

Scrape trending Reddit posts from public subreddit feeds with authors, links, timestamps, flair, NSFW flags, trendScore and available score/comment data. Perfect for SEO and AI agents, MCP optimized.

- **URL**: https://apify.com/khadinakbar/reddit-trends-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Social media, MCP servers
- **Stats:** 1 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 reddit post scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Trends Scraper

Reddit Trends Scraper extracts trending Reddit posts from public subreddit feeds into clean JSON for market research, social listening, content ideation, brand monitoring, and AI agents.

It is built for buyers who need fast Reddit trend signals without handling Reddit page parsing themselves. Use it to watch specific communities, rank posts by engagement or feed order, and feed structured Reddit data into dashboards, alerts, enrichment workflows, or MCP clients.

### What It Extracts

| Field | Description |
| --- | --- |
| `postId` | Reddit post ID |
| `rank` | Rank within the source feed page |
| `title` | Post title |
| `subreddit` | Community where the post appeared |
| `author` | Visible Reddit username when available |
| `postUrl` | External URL or Reddit post URL |
| `permalink` | Canonical Reddit comments URL |
| `domain` | Linked domain such as `self.artificial` |
| `score` | Visible Reddit score when available |
| `commentCount` | Visible comment count when available |
| `upvoteRatio` | Upvote ratio when available |
| `createdAt` | Post timestamp when available |
| `isNsfw` | Whether Reddit marked the post as adult content |
| `flair` | Post flair label |
| `sourceMode` | `subreddit` |
| `sourceName` | Subreddit name |
| `trendScore` | Actor-computed trend signal based on score, comments, recency and rank |
| `rawSource` | Extraction path used: ScrapeCreators, Reddit JSON, Reddit RSS, or old Reddit HTML |

### When To Use

Use Reddit Trends Scraper when you need public Reddit posts that are gaining traction inside known communities. Good use cases include monitoring product categories, finding discussion topics before they hit mainstream social feeds, tracking competitor communities, researching content ideas, collecting social proof, and building Reddit-aware agents.

Use the `subreddits` input when you already know the communities you care about, such as `artificial`, `SaaS`, `Entrepreneur`, or `LocalLLaMA`.

Do not use this actor for Reddit-wide keyword search, private Reddit content, logged-in feeds, user inboxes, voting, posting, moderation actions, or deep comment-thread scraping. It is a subreddit trend-post scraper, not a Reddit account automation tool and not a comment scraper.

### Input Examples

```json
{
  "subreddits": ["artificial", "technology", "Futurology"],
  "sort": "hot",
  "maxResults": 50,
  "maxPagesPerSource": 2
}
````

#### MCP-Friendly Run

```json
{
  "subreddits": ["artificial", "LocalLLaMA"],
  "responseFormat": "concise",
  "maxResults": 30
}
```

### Output Example

```json
{
  "postId": "1u3acx4",
  "rank": 1,
  "title": "Claude Fable made me realize I don't need a better model",
  "subreddit": "artificial",
  "author": "Axi0m-22",
  "postUrl": "https://www.reddit.com/r/artificial/comments/1u3acx4/example/",
  "permalink": "https://www.reddit.com/r/artificial/comments/1u3acx4/example/",
  "domain": "self.artificial",
  "score": 193,
  "commentCount": 86,
  "upvoteRatio": null,
  "createdAt": "2026-06-11T20:23:35.000Z",
  "ageHours": 15.8,
  "isSelfPost": true,
  "isVideo": false,
  "isNsfw": false,
  "flair": "Discussion",
  "sourceMode": "subreddit",
  "sourceName": "artificial",
  "sort": "hot",
  "timeRange": null,
  "trendScore": 214.52,
  "scrapedAt": "2026-06-12T12:30:00.000Z",
  "rawSource": "scrapecreators"
}
```

### Pricing

This actor uses Pay Per Event pricing and also supports Apify platform usage billing. You are charged only for records saved to the dataset.

| Event | Price |
| --- | ---: |
| Actor start | $0.00005 per run start, scaled by memory |
| Reddit post scraped | $0.008 per post |

Example costs:

| Run size | Estimated PPE cost |
| --- | ---: |
| 25 posts | About $0.200 |
| 50 posts | About $0.400 |
| 250 posts | About $2.000 |

The actor prints a cost cap at run start. If `maxResults` is 50, it will not charge for more than 50 Reddit post events.

### Reliability Notes

The scraper uses an owner-managed ScrapeCreators provider key as its primary cloud path, then falls back to Reddit public JSON, Reddit RSS and old Reddit HTML listings when provider data is unavailable. This matters because Reddit often applies strict network security rules to cloud traffic, while the provider route returns subreddit post data without requiring user cookies or Reddit account credentials.

The actor defaults to Apify Residential proxy for the direct Reddit fallback path because Reddit commonly blocks Apify cloud datacenter IPs. If every source is blocked or unavailable, retry with fewer pages per source or a different proxy country. The actor records request counts, blocked counts, skipped duplicates, filtered posts, warnings, and stop reason in `RUN_SUMMARY`.

The scraper does not bypass private communities, quarantined communities, deleted content, or account-only experiences. NSFW posts are skipped by default and can be included with `includeNsfw: true`.

### AI Agent And MCP Use

Tool description draft:

Scrape trending Reddit posts from public subreddit feeds for social listening, content research and market monitoring. Do not use for Reddit search, comments or account automation. Returns one row per post with title, subreddit, author, links, timestamps, flair and trendScore. Charged $0.008/post.

The default `responseFormat` is `concise`, which keeps each dataset item compact for agents. Use `detailed` when you want extra fields such as `textPreview` from Reddit JSON when available.

### API Usage

```bash
apify call khadinakbar/reddit-trends-scraper --input='{
  "subreddits": ["artificial", "technology"],
  "maxResults": 50
}'
```

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('khadinakbar/reddit-trends-scraper').call({
  subreddits: ['artificial', 'LocalLLaMA'],
  sort: 'hot',
  maxResults: 25,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Related Actors

Use this actor for subreddit trend posts and community monitoring. Use a dedicated Reddit comments scraper when you need full comment threads, and use a Reddit search actor when you need keyword search across all of Reddit. Use social media actors for TikTok, Instagram, Facebook, LinkedIn, or X when the conversation is happening outside Reddit.

### Legal And Compliance

This actor extracts publicly visible Reddit listing data. You are responsible for using the output in compliance with Reddit policies, applicable laws, privacy rules, and your own data retention requirements. Do not use the actor to collect private, sensitive, or restricted content.

# Actor input Schema

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

Use this when monitoring specific Reddit communities. Enter names without r/, for example artificial, technology, or Futurology. Defaults to artificial, technology, and Futurology. This is not a full Reddit URL list.

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

Use this when selecting subreddit listing order. Accepted values are hot, rising, top, new, or controversial. Defaults to hot and supports timeRange for top and controversial.

## `timeRange` (type: `string`):

Use this when top or controversial feeds need a time window. Accepted values are hour, day, week, month, year, or all. Defaults to week for trend discovery. This is not a date range picker.

## `maxResults` (type: `integer`):

Use this when capping the number of Reddit posts returned and charged. Accepted range is 1 to 500. Defaults to 50. This is not the number of pages; use maxPagesPerSource for pagination.

## `maxPagesPerSource` (type: `integer`):

Use this when each subreddit should paginate deeper. Accepted range is 1 to 10 pages per source. Defaults to 2 for fast quality-test runs. This is not a result limit.

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

Use this when NSFW Reddit posts should be included in the dataset. Defaults to false, so NSFW records are skipped. Set true only when your workflow can handle adult or sensitive content. This does not bypass private or quarantined communities.

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

Use this when low-score posts should be filtered out. Enter a non-negative Reddit score such as 25 or 100. Defaults to 0. This is not a trendScore threshold.

## `responseFormat` (type: `string`):

Use this when choosing dataset detail level for humans or agents. concise returns stable trend fields under a small token budget, while detailed adds raw fullname and textPreview when available. Defaults to concise. This is not a file format selector.

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

Use this when Reddit blocks direct requests from the actor. Apify Residential proxy is the safest fallback, for example useApifyProxy true with RESIDENTIAL group. Defaults to Apify Residential proxy for cloud reliability. This is not a login or cookie setting.

## Actor input object example

```json
{
  "subreddits": [
    "artificial",
    "technology"
  ],
  "sort": "hot",
  "timeRange": "week",
  "maxResults": 50,
  "maxPagesPerSource": 2,
  "includeNsfw": false,
  "minScore": 25,
  "responseFormat": "concise",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `records` (type: `string`):

Default dataset containing one item per Reddit trend post.

## `recordsCsv` (type: `string`):

CSV export of the same Reddit trend post records.

## `runSummary` (type: `string`):

Run summary stored in the default key-value store.

## `output` (type: `string`):

Compact MCP-friendly output record.

# 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": [
        "artificial",
        "technology",
        "Futurology"
    ],
    "sort": "hot",
    "timeRange": "week",
    "maxResults": 50,
    "maxPagesPerSource": 2,
    "includeNsfw": false,
    "minScore": 0,
    "responseFormat": "concise"
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/reddit-trends-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": [
        "artificial",
        "technology",
        "Futurology",
    ],
    "sort": "hot",
    "timeRange": "week",
    "maxResults": 50,
    "maxPagesPerSource": 2,
    "includeNsfw": False,
    "minScore": 0,
    "responseFormat": "concise",
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/reddit-trends-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": [
    "artificial",
    "technology",
    "Futurology"
  ],
  "sort": "hot",
  "timeRange": "week",
  "maxResults": 50,
  "maxPagesPerSource": 2,
  "includeNsfw": false,
  "minScore": 0,
  "responseFormat": "concise"
}' |
apify call khadinakbar/reddit-trends-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Trends Scraper",
        "description": "Scrape trending Reddit posts from public subreddit feeds with authors, links, timestamps, flair, NSFW flags, trendScore and available score/comment data. Perfect for SEO and AI agents, MCP optimized.",
        "version": "1.1",
        "x-build-id": "CTFvdsBQN7cyjxZvE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~reddit-trends-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-reddit-trends-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/khadinakbar~reddit-trends-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-reddit-trends-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/khadinakbar~reddit-trends-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-reddit-trends-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",
                "properties": {
                    "subreddits": {
                        "title": "Subreddits",
                        "type": "array",
                        "description": "Use this when monitoring specific Reddit communities. Enter names without r/, for example artificial, technology, or Futurology. Defaults to artificial, technology, and Futurology. This is not a full Reddit URL list.",
                        "default": [
                            "artificial",
                            "technology",
                            "Futurology"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "sort": {
                        "title": "Subreddit sort",
                        "enum": [
                            "hot",
                            "rising",
                            "top",
                            "new",
                            "controversial"
                        ],
                        "type": "string",
                        "description": "Use this when selecting subreddit listing order. Accepted values are hot, rising, top, new, or controversial. Defaults to hot and supports timeRange for top and controversial.",
                        "default": "hot"
                    },
                    "timeRange": {
                        "title": "Time range",
                        "enum": [
                            "hour",
                            "day",
                            "week",
                            "month",
                            "year",
                            "all"
                        ],
                        "type": "string",
                        "description": "Use this when top or controversial feeds need a time window. Accepted values are hour, day, week, month, year, or all. Defaults to week for trend discovery. This is not a date range picker.",
                        "default": "week"
                    },
                    "maxResults": {
                        "title": "Maximum posts",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Use this when capping the number of Reddit posts returned and charged. Accepted range is 1 to 500. Defaults to 50. This is not the number of pages; use maxPagesPerSource for pagination.",
                        "default": 50
                    },
                    "maxPagesPerSource": {
                        "title": "Pages per source",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Use this when each subreddit should paginate deeper. Accepted range is 1 to 10 pages per source. Defaults to 2 for fast quality-test runs. This is not a result limit.",
                        "default": 2
                    },
                    "includeNsfw": {
                        "title": "Include NSFW posts",
                        "type": "boolean",
                        "description": "Use this when NSFW Reddit posts should be included in the dataset. Defaults to false, so NSFW records are skipped. Set true only when your workflow can handle adult or sensitive content. This does not bypass private or quarantined communities.",
                        "default": false
                    },
                    "minScore": {
                        "title": "Minimum score",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Use this when low-score posts should be filtered out. Enter a non-negative Reddit score such as 25 or 100. Defaults to 0. This is not a trendScore threshold.",
                        "default": 0
                    },
                    "responseFormat": {
                        "title": "Response format",
                        "enum": [
                            "concise",
                            "detailed"
                        ],
                        "type": "string",
                        "description": "Use this when choosing dataset detail level for humans or agents. concise returns stable trend fields under a small token budget, while detailed adds raw fullname and textPreview when available. Defaults to concise. This is not a file format selector.",
                        "default": "concise"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Use this when Reddit blocks direct requests from the actor. Apify Residential proxy is the safest fallback, for example useApifyProxy true with RESIDENTIAL group. Defaults to Apify Residential proxy for cloud reliability. This is not a login or cookie setting.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
