# Reddit Scraper — Posts, Comments, Search & Users (Reliable) (`blubberstick/reddit-scraper`) Actor

Scrape Reddit posts, comment trees, search results, and user activity as clean JSON — engineered for reliability: rate-limit-aware pacing, host + proxy rotation, and per-target fault isolation. HTTP-only, no browser, no login.

- **URL**: https://apify.com/blubberstick/reddit-scraper.md
- **Developed by:** [William Fordyce](https://apify.com/blubberstick) (community)
- **Categories:** Social media, Marketing, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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 Scraper — Posts, Comments, Search & Users (Reliable)

A **Reddit scraper** built for one thing above all: **finishing every run**. Scrape **subreddit posts**, full **comment trees**, **Reddit search** results, and **user post/comment history** as clean JSON — no login, no cookies, no official **Reddit API** key, and no headless browser. Built for **social listening**, **brand monitoring**, market research, and dataset building.

### Why this scraper succeeds where others fail

Reddit aggressively defends its public endpoints: rate limits (HTTP 429), IP blocks (HTTP 403), and a JavaScript "Please wait for verification" bot wall that silently breaks plain `.json` scrapers. That wall is exactly why other Reddit actors fail 40%+ of their runs. This actor was engineered around those failure modes from day one:

- **Native anonymous identity** — instead of hammering the fragile public `.json` pages, the actor performs the exact same anonymous handshake reddit.com runs for every logged-out visitor and reads data through Reddit's own application gateway. No account, no login, no credentials — and no JS-challenge wall.
- **Rate-limit-aware pacing** — the actor reads Reddit's `x-ratelimit-remaining` / `x-ratelimit-reset` response headers on every request and **proactively slows down before a 429 ever happens**, on top of politely jittered 1–2 s request spacing.
- **Four-host fallback ladder** — if Reddit's gateway ever misbehaves, requests automatically fail over across four hosts that serve identical data (`oauth` → `www` → `old` → `api` .reddit.com).
- **Proxy session rotation** — when running with Apify residential proxies (the default), every blocked request retries from a brand-new IP session with a brand-new identity and a fresh rate-limit budget.
- **Exponential backoff with jitter** — retries start at ~2 s and back off up to 60 s (max 5 attempts per request), so transient hiccups never become failed runs.
- **Per-target fault isolation** — one private, banned, or misspelled subreddit never kills your run. Failures are recorded as `dataType: "error"` items and every other target still delivers.
- **HTTP-only, no headless browser** — runs in 256–512 MB of memory, fast and cheap.

### What you can scrape

| Mode | Input | What you get |
|---|---|---|
| **Subreddits** | `subreddits` + `sort` / `topPeriod` | Posts from hot / new / top / rising listings — a complete **subreddit scraper**. |
| **Search** | `searchQueries` (+ optional `searchSubreddit`) | Posts matching any keyword across all of Reddit or inside one subreddit — ideal for **brand monitoring**. |
| **Users** | `users` + `userDataType` | Any user's submitted posts, comments, or both. |
| **Start URLs** | `startUrls` | Paste any Reddit URL — subreddit, post, user, or search page. The type is auto-detected. |
| **Comments** | `includeComments: true` | The full comment tree of every scraped post, flattened into one item per comment — a true **Reddit comments scraper**. |

All modes are combinable in a single run, and `maxItems` is split fairly across all your targets.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `startUrls` | array | `[]` | Reddit URLs of any type (subreddit / post / user / search) — auto-detected. |
| `subreddits` | array | `[]` | Subreddit names, with or without `r/`. |
| `sort` | enum | `new` | `hot`, `new`, `top`, `rising`. |
| `topPeriod` | enum | `week` | `hour`, `day`, `week`, `month`, `year`, `all` (only for `top`). |
| `searchQueries` | array | `[]` | Keywords/phrases to search for. |
| `searchSort` | enum | `relevance` | `relevance`, `hot`, `top`, `new`, `comments`. |
| `searchSubreddit` | string | `""` | Restrict all searches to one subreddit. |
| `users` | array | `[]` | Usernames, with or without `u/`. |
| `userDataType` | enum | `posts` | `posts`, `comments`, or `both`. |
| `includeComments` | boolean | `false` | Also fetch each post's comment tree. |
| `maxItems` | integer | `100` | Max posts/user items across all sources combined (budget is split fairly per target). |
| `maxCommentsPerPost` | integer | `50` | Comment cap per post when `includeComments` is on. |
| `proxyConfiguration` | object | Apify residential | Proxy settings. Residential strongly recommended. |

Example input — monitor two subreddits and a brand keyword, with comments:

```json
{
    "subreddits": ["programming", "smallbusiness"],
    "sort": "new",
    "searchQueries": ["apify"],
    "includeComments": true,
    "maxItems": 60,
    "maxCommentsPerPost": 20
}
````

### Output

One dataset item per post and per comment.

**Post** (`dataType: "post"`):

```json
{
    "dataType": "post",
    "id": "1u28egw",
    "subreddit": "programming",
    "url": "https://example.com/article",
    "title": "The new unwritten laws of software engineering",
    "author": "whiskeytown79",
    "selftext": "",
    "score": 1240,
    "upvoteRatio": 0.95,
    "numComments": 312,
    "createdAt": "2026-06-10T17:34:44.000Z",
    "flair": "Discussion",
    "isNsfw": false,
    "mediaUrls": ["https://external-preview.redd.it/..."],
    "permalink": "https://www.reddit.com/r/programming/comments/1u28egw/...",
    "fetchedAt": "2026-06-10T21:12:20.233Z",
    "commentsScraped": 20,
    "moreCommentsSkipped": 12
}
```

`commentsScraped` / `moreCommentsSkipped` appear when `includeComments` is on — `moreCommentsSkipped` counts the comments hiding behind Reddit's "load more comments" stubs beyond your per-post cap.

**Comment** (`dataType: "comment"`) — `postId`, `parentId`, and `depth` let you re-assemble the full thread tree (`depth: 0` = top level, where `parentId === postId`):

```json
{
    "dataType": "comment",
    "id": "oqvw4be",
    "postId": "1u28egw",
    "parentId": "oqvmfr6",
    "depth": 1,
    "subreddit": "programming",
    "author": "vattenpuss",
    "body": "Oh you didn't get the memo? ...",
    "score": 21,
    "createdAt": "2026-06-10T18:02:11.000Z",
    "flair": null,
    "permalink": "https://www.reddit.com/r/programming/comments/1u28egw/.../oqvw4be/",
    "fetchedAt": "2026-06-10T21:12:24.108Z"
}
```

**Error** (`dataType: "error"`) — pushed instead of crashing when a single target fails; the run continues and still succeeds:

```json
{
    "dataType": "error",
    "target": "r/some_private_subreddit",
    "error": "Reddit refused access (HTTP 403: private)",
    "fetchedAt": "2026-06-10T21:17:48.974Z"
}
```

### Pricing (pay per event)

You only pay for data you actually receive:

| Event | Charged when | Suggested price |
|---|---|---|
| `item-scraped` | One post or comment is pushed to the dataset | $0.002 |

Error items are **never** charged. Example: 100 posts with 50 comments each = 5,100 items ≈ **$10.20**; 500 posts without comments ≈ **$1.00**.

### FAQ

**Is it legal to scrape Reddit?**
This actor only collects publicly available data — the same posts and comments anyone can read in a browser without logging in. It collects no private data and accesses no user accounts. As always, consult your own counsel for your specific use case and respect Reddit's User Agreement when republishing content.

**Do I need a Reddit account, API key, or cookies?**
No. The actor uses the same anonymous identity Reddit's own website creates for every logged-out visitor. There is nothing to configure, nothing to expire, and no account that can be banned.

**How is this different from other Reddit scrapers?**
Reliability. The most popular Reddit actors fail a large share of their runs because they treat Reddit's rate limits and bot-wall responses as fatal errors. This actor paces itself using Reddit's own rate-limit headers, retries with exponential backoff, rotates proxy sessions and fallback hosts automatically, and isolates per-target failures — so one bad subreddit or one throttled request never costs you a run.

**Why are some comments missing?**
Reddit returns large threads partially, hiding deeper branches behind "load more comments" stubs. The actor scrapes up to `maxCommentsPerPost` comments per post and reports how many remained hidden as `moreCommentsSkipped` on the post item, so you always know what you got.

**Can I monitor subreddits or keywords on a schedule?**
Yes — add the actor to an Apify Schedule (e.g. every hour with `sort: "new"`) and connect a webhook or one of Apify's integrations (Google Sheets, Slack, Make, Zapier) for an always-on **social listening** pipeline.

**What proxies should I use?**
Apify residential proxies (the default). Reddit blocks most datacenter IP ranges outright; residential sessions combined with the actor's automatic rotation deliver the reliability this actor is built for.

### Tips

- For monitoring use cases, `sort: "new"` + a schedule beats `hot` — you see every post once, as it appears.
- Brand monitoring works best with `searchQueries` + `includeComments: true` — the sentiment usually lives in the comments.
- Use `searchSort: "comments"` to find the most discussed posts about a topic.
- Keep `maxItems` aligned with your schedule frequency (e.g. hourly runs rarely need more than 100 items per subreddit).

# Actor input Schema

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

Any Reddit URLs — subreddit pages, individual posts, user profiles, or search-result pages. The type of each URL is detected automatically. Examples: <code>https://www.reddit.com/r/programming/top/?t=week</code>, <code>https://www.reddit.com/r/AskReddit/comments/abc123/some\_post/</code>, <code>https://www.reddit.com/user/spez/</code>, <code>https://www.reddit.com/search/?q=apify</code>.

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

Subreddit names to scrape posts from, with or without the <code>r/</code> prefix — e.g. <code>programming</code> or <code>r/programming</code>.

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

Which subreddit listing to scrape — same tabs you see on Reddit. <code>new</code> is best for monitoring, <code>top</code> for the most popular posts in a period.

## `topPeriod` (type: `string`):

Time window for the <code>top</code> sort (ignored for other sorts).

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

Keywords or phrases to search Reddit for — e.g. your brand name, a product, a topic. Each query returns matching posts. Great for social listening and brand monitoring.

## `searchSort` (type: `string`):

How to rank search results.

## `searchSubreddit` (type: `string`):

Optional: limit all search queries to a single subreddit, e.g. <code>smallbusiness</code>. Leave empty to search all of Reddit.

## `users` (type: `array`):

Reddit usernames to scrape, with or without the <code>u/</code> prefix — e.g. <code>spez</code>.

## `userDataType` (type: `string`):

Whether to scrape each user's submitted posts, their comments, or both.

## `includeComments` (type: `boolean`):

For every scraped post, also fetch and flatten its comment tree (one dataset item per comment, with <code>postId</code>, <code>parentId</code>, and <code>depth</code> for re-assembly). Adds one extra request per post.

## `maxItems` (type: `integer`):

Maximum number of posts / user items scraped across all sources combined — the budget is split fairly across your subreddits, queries, users, and URLs. Comments fetched via <b>Include comments</b> are controlled separately by <b>Max comments per post</b>.

## `maxCommentsPerPost` (type: `integer`):

Cap on comments scraped per post when <b>Include comments</b> is on. Deeply nested "load more comments" stubs are skipped and their count is reported on the post item as <code>moreCommentsSkipped</code>.

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

Proxies to use. Residential proxies (default) are strongly recommended — Reddit aggressively blocks datacenter IP ranges. The actor automatically rotates to a fresh proxy session whenever Reddit rate-limits or blocks a request.

## Actor input object example

```json
{
  "startUrls": [],
  "subreddits": [
    "programming"
  ],
  "sort": "new",
  "topPeriod": "week",
  "searchQueries": [],
  "searchSort": "relevance",
  "searchSubreddit": "",
  "users": [],
  "userDataType": "posts",
  "includeComments": false,
  "maxItems": 100,
  "maxCommentsPerPost": 50,
  "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 = {
    "startUrls": [],
    "subreddits": [
        "programming"
    ],
    "searchQueries": [],
    "users": [],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "startUrls": [],
    "subreddits": ["programming"],
    "searchQueries": [],
    "users": [],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

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

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [],
  "subreddits": [
    "programming"
  ],
  "searchQueries": [],
  "users": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call blubberstick/reddit-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Scraper — Posts, Comments, Search & Users (Reliable)",
        "description": "Scrape Reddit posts, comment trees, search results, and user activity as clean JSON — engineered for reliability: rate-limit-aware pacing, host + proxy rotation, and per-target fault isolation. HTTP-only, no browser, no login.",
        "version": "0.1",
        "x-build-id": "FWDVOqeRStHxZtud8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/blubberstick~reddit-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-blubberstick-reddit-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/blubberstick~reddit-scraper/runs": {
            "post": {
                "operationId": "runs-sync-blubberstick-reddit-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/blubberstick~reddit-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-blubberstick-reddit-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Any Reddit URLs — subreddit pages, individual posts, user profiles, or search-result pages. The type of each URL is detected automatically. Examples: <code>https://www.reddit.com/r/programming/top/?t=week</code>, <code>https://www.reddit.com/r/AskReddit/comments/abc123/some_post/</code>, <code>https://www.reddit.com/user/spez/</code>, <code>https://www.reddit.com/search/?q=apify</code>.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "subreddits": {
                        "title": "Subreddits",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Subreddit names to scrape posts from, with or without the <code>r/</code> prefix — e.g. <code>programming</code> or <code>r/programming</code>.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sort": {
                        "title": "Sort posts by",
                        "enum": [
                            "hot",
                            "new",
                            "top",
                            "rising"
                        ],
                        "type": "string",
                        "description": "Which subreddit listing to scrape — same tabs you see on Reddit. <code>new</code> is best for monitoring, <code>top</code> for the most popular posts in a period.",
                        "default": "new"
                    },
                    "topPeriod": {
                        "title": "Top period",
                        "enum": [
                            "hour",
                            "day",
                            "week",
                            "month",
                            "year",
                            "all"
                        ],
                        "type": "string",
                        "description": "Time window for the <code>top</code> sort (ignored for other sorts).",
                        "default": "week"
                    },
                    "searchQueries": {
                        "title": "Search queries",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Keywords or phrases to search Reddit for — e.g. your brand name, a product, a topic. Each query returns matching posts. Great for social listening and brand monitoring.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchSort": {
                        "title": "Search sort",
                        "enum": [
                            "relevance",
                            "hot",
                            "top",
                            "new",
                            "comments"
                        ],
                        "type": "string",
                        "description": "How to rank search results.",
                        "default": "relevance"
                    },
                    "searchSubreddit": {
                        "title": "Restrict search to subreddit",
                        "type": "string",
                        "description": "Optional: limit all search queries to a single subreddit, e.g. <code>smallbusiness</code>. Leave empty to search all of Reddit.",
                        "default": ""
                    },
                    "users": {
                        "title": "Users",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Reddit usernames to scrape, with or without the <code>u/</code> prefix — e.g. <code>spez</code>.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "userDataType": {
                        "title": "User data to fetch",
                        "enum": [
                            "posts",
                            "comments",
                            "both"
                        ],
                        "type": "string",
                        "description": "Whether to scrape each user's submitted posts, their comments, or both.",
                        "default": "posts"
                    },
                    "includeComments": {
                        "title": "Include comments",
                        "type": "boolean",
                        "description": "For every scraped post, also fetch and flatten its comment tree (one dataset item per comment, with <code>postId</code>, <code>parentId</code>, and <code>depth</code> for re-assembly). Adds one extra request per post.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of posts / user items scraped across all sources combined — the budget is split fairly across your subreddits, queries, users, and URLs. Comments fetched via <b>Include comments</b> are controlled separately by <b>Max comments per post</b>.",
                        "default": 100
                    },
                    "maxCommentsPerPost": {
                        "title": "Max comments per post",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Cap on comments scraped per post when <b>Include comments</b> is on. Deeply nested \"load more comments\" stubs are skipped and their count is reported on the post item as <code>moreCommentsSkipped</code>.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxies to use. Residential proxies (default) are strongly recommended — Reddit aggressively blocks datacenter IP ranges. The actor automatically rotates to a fresh proxy session whenever Reddit rate-limits or blocks a request.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```