# Reddit Subreddit Scraper V2 (`myagizm/reddit-subreddit-scraper-v2`) Actor

Reddit Subreddit Scraper V2 — cached data source (results may lag up to ~1.5h). Structured JSON, no login, no API key. For real-time data use the V1 actor.

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

## Pricing

from $1.10 / 1,000 results

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

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Scraper V2 — Scrape Subreddit Posts to JSON, CSV & Excel (No API Key, No Login)

<p align="center">
Scrape any subreddit's posts — titles, scores, authors, flair, body text and media — into clean structured data, with <b>no login</b>, <b>no API key</b>, and <b>no cookies or account required</b>. Export scraped data to JSON, CSV, Excel, or XML, schedule runs via API, and integrate with your tools and AI workflows.
</p>

<p align="center">
<b>Built for AI agents:</b> plug it into <b>Claude</b>, <b>ChatGPT / Codex</b>, and <b>Cursor</b> through the Apify MCP server and let your agent scrape fresh Reddit posts on demand.
</p>

<p align="center">
<a href="https://apify.com/myagizm/reddit-subreddit-scraper-v2"><img src="https://img.shields.io/badge/Try%20Now-Reddit%20Subreddit%20Scraper%20V2-38a169?style=for-the-badge" alt="Try Now"></a>
<a href="https://apify.com/myagizm/reddit-subreddit-scraper-v2/input-schema"><img src="https://img.shields.io/badge/Input%20Schema-View-3182ce?style=for-the-badge" alt="Input Schema"></a>
<a href="https://apify.com/myagizm/reddit-subreddit-scraper-v2/api"><img src="https://img.shields.io/badge/API%20Docs-Reference-805ad5?style=for-the-badge" alt="API Docs"></a>
</p>

<p align="center">
<a href="#what-can-reddit-subreddit-scraper-v2-do">What it can do</a> •
<a href="#use-with-ai-agents-mcp">AI agents (MCP)</a> •
<a href="#how-to-scrape-a-subreddit">How to scrape</a> •
<a href="#what-data-can-i-scrape-from-a-subreddit">Output data</a> •
<a href="#limiting-results">Limiting results</a> •
<a href="#output-example">Output example</a> •
<a href="#how-much-does-scraping-a-subreddit-cost">Pricing</a> •
<a href="#integrations">Integrations</a> •
<a href="#faq">FAQ</a> •
<a href="#want-other-reddit-data">Other Reddit actors</a>
</p>

---

### What can Reddit Subreddit Scraper V2 do? {#what-can-reddit-subreddit-scraper-v2-do}

**Reddit Subreddit Scraper V2** lets you scrape a subreddit — or dozens of subreddits at once — and returns every post as clean, structured JSON you can download as JSON, CSV, Excel, or XML, or pull straight into your app, spreadsheet, or AI agent. It is the fastest way to scrape Reddit posts at scale without touching HTML.

Give it a list of subreddit names (like `AskReddit`, `technology`, or `forhire`), choose how you want the listing sorted, and the actor walks the subreddit's feed and returns every post with its title, score, author, flair, comment count, self text, and media URLs.

There is **no API key**, **no login**, and **no OAuth setup** — **no cookies or account required**. You do not need a Reddit developer account, a registered app, or rate-limit credentials, so you can **go beyond the limitations of the official Reddit API** and scrape Reddit posts at scale. The actor handles fetching, pagination, filtering, and formatting for you. It only collects **publicly available data**. **Get your first results free in under 2 minutes.**

> This is the **V2** edition, tuned for stability and large batch jobs. It reads from a cached source, so results may lag up to ~1.5 hours behind the live site. If you need up-to-the-minute posts, use the real-time **[Reddit Scraper V2](https://apify.com/myagizm/reddit-scraper-v2)** or the V1 subreddit actor instead.

#### ✅ Scrape any public subreddit

Point the actor at any public subreddit by name — the `r/` prefix is optional. Scrape a single community or scrape a bunch of subreddits at once in one run. Works for large default subs (`AskReddit`, `news`, `worldnews`) and niche communities (`forhire`, `SaaS`, `indiehackers`) alike, with **no limitations on the number of requests**.

#### 🗂️ Full post metadata

Every post you scrape comes back with rich fields: `id`, `title`, `author`, `score`, `upvoteRatio`, `numComments`, `flair`, `domain`, `createdUtc`, `nsfw`, `stickied`, `archived`, and more. No scraping HTML, no parsing — just clean columns.

#### 💬 Scrape post body / self text

Toggle `includeSelftext` to scrape the full body of each self post — perfect for keyword analysis, lead generation, and sentiment work. The raw Markdown text is preserved so links and formatting stay intact.

#### 📊 Sort, time windows & keyword filters

Sort the posts you scrape by **New**, **Hot**, **Top**, **Rising**, or **Controversial**, apply a **time window** (past hour → all time) for Top/Controversial, keep only posts after a given date, and filter down to posts that mention specific keywords.

#### 🔄 Multi-subreddit batching with per-source caps

Pass many subreddits at once and set a per-subreddit cap so no single community dominates your dataset. Great for building balanced, comparable datasets when you scrape multiple subreddits at once.

#### ⚡ Media extraction

Flip `includeMedia` on to capture image and video URLs — `i.redd.it`, `v.redd.it`, imgur links, and gallery posts — alongside each post record you scrape.

#### 🧰 Export scraped data anywhere

Download the subreddit posts you scrape as **JSON**, **CSV**, **Excel**, **XML**, HTML table, or RSS, or fetch them through the API. Feed them into BI tools, databases, spreadsheets, or AI pipelines — **fast, fresh data** with no caching layer to configure.

---

### Use with AI agents — Claude, ChatGPT & Cursor (MCP) {#use-with-ai-agents-mcp}

Reddit Subreddit Scraper V2 is fully compatible with the **Apify MCP (Model Context Protocol) server**, so AI agents and assistants can run it as a tool and scrape subreddit posts on demand.

- **Claude** (Claude Desktop, Claude Code) — add the Apify MCP server and let Claude call the actor to scrape posts from any subreddit.
- **ChatGPT / Codex** — expose the actor as a tool so your GPT or Codex agent can scrape Reddit data on demand.
- **Cursor** — wire the actor into your IDE agent to enrich research, monitoring, or lead-gen flows.

Because output is clean structured JSON, agents can reason over it directly — summarize a subreddit, extract leads, rank posts by score, or watch a community for keywords.

You can also chain the actor into no-code and automation tools via their MCP or native connectors: **Make, Zapier, n8n, Slack, Airbyte, Gumloop, CrewAI, IFTTT, Lindy, GitHub, Google Sheets, Google Drive**, and more.

---

### How to scrape a subreddit {#how-to-scrape-a-subreddit}

1. Open **[Reddit Subreddit Scraper V2](https://apify.com/myagizm/reddit-subreddit-scraper-v2)** on Apify.
2. In **Subreddits**, add one or more subreddit names — e.g. `AskReddit`, `technology`. The `r/` prefix is optional.
3. Pick a **Sort** order: New, Hot, Top, Rising, or Controversial.
4. For Top/Controversial, choose a **Time range** (past hour → all time).
5. Optionally toggle **Include post text**, **Include media URLs**, and **Include NSFW**.
6. Set **Max items** and **Max posts per subreddit** to control how many posts you scrape.
7. Click **▶ Start**, wait for the run to finish, then **Export** the scraped data as JSON, CSV, Excel, or XML — or grab it via the API.

No account, cookies, or API key required. Paste subreddit names and scrape.

---

### What data can I scrape from a subreddit? {#what-data-can-i-scrape-from-a-subreddit}

Each post you scrape is returned as one dataset item. The most useful fields:

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Reddit post ID (e.g. `t3_1v1gas0`) |
| `url` | string | Full permalink to the post |
| `type` | string | Record type — always `post` |
| `title` | string | Post title |
| `author` | string | Username of the poster |
| `subreddit` | string | Subreddit the post belongs to |
| `flair` | string | Post flair / tag (e.g. `For Hire`) |
| `score` | integer | Net upvotes (upvotes − downvotes) |
| `upvoteRatio` | number | Ratio of upvotes (0–1) |
| `numComments` | integer | Number of comments |
| `selftext` | string | Full post body text (if `includeSelftext`) |
| `isSelf` | boolean | Whether it is a self/text post |
| `domain` | string | Source domain (e.g. `self.forhire`) |
| `outboundUrl` | string | External link URL, if the post links out |
| `thumbnail` | string | Thumbnail image URL, if any |
| `nsfw` | boolean | Flagged over-18 / NSFW |
| `spoiler` | boolean | Marked as a spoiler |
| `stickied` | boolean | Pinned/stickied in the subreddit |
| `archived` | boolean | Post is archived |
| `edited` | boolean | Whether the post was edited |
| `gilded` | integer | Number of awards received |
| `createdUtc` | string | Creation time (ISO 8601 UTC) |
| `createdUtcEpoch` | integer | Creation time (Unix epoch seconds) |
| `scrapedAt` | string | When the record was collected (ISO 8601) |
| `sourceType` | string | Data origin marker — `reddit` |

---

### Use cases — why scrape a subreddit?

- **Lead generation** — scrape `forhire`, `slavelabour`, `hiring`, or freelance subs for people offering or requesting services.
- **Market & product research** — track what a community is talking about, upvoting, and complaining about.
- **Content & trend monitoring** — scrape Hot/Top posts daily to spot emerging topics.
- **Brand & reputation monitoring** — filter the posts you scrape by keyword to catch mentions of your product or competitors.
- **Academic & social research** — build reproducible datasets of subreddit activity over time.
- **AI / LLM training data** — collect large volumes of titles and self text for analysis or fine-tuning.
- **SEO & keyword research** — discover the exact language and questions your audience uses.
- **Community analytics dashboards** — feed scores, comment counts, and timestamps into BI tools.

---

### Input examples

All examples use the **real input field names**. Only `subreddits` is required.

#### Scrape a single subreddit (Hot)

```json
{
  "subreddits": ["AskReddit"],
  "sort": "hot",
  "maxItems": 50
}
````

#### Scrape top posts of the week across multiple subreddits

```json
{
  "subreddits": ["technology", "programming", "webdev"],
  "sort": "top",
  "time": "week",
  "includeSelftext": true,
  "maxItems": 100,
  "maxPostsPerSource": 25
}
```

#### Lead generation on r/forhire with keyword + date filters

```json
{
  "subreddits": ["forhire"],
  "sort": "new",
  "includeSelftext": true,
  "searchTerms": ["hiring", "developer", "shopify"],
  "postDateLimit": "2026-01-01",
  "maxItems": 100
}
```

#### Deep pagination with media URLs

```json
{
  "subreddits": ["pics", "aww"],
  "sort": "top",
  "time": "month",
  "includeMedia": true,
  "maxPages": 5,
  "maxItems": 100
}
```

#### Include NSFW and controversial posts

```json
{
  "subreddits": ["news"],
  "sort": "controversial",
  "time": "day",
  "includeNSFW": true,
  "maxItems": 40
}
```

***

### Input reference

| Field | Title | Type | Default | Notes |
|-------|-------|------|---------|-------|
| `subreddits` | Subreddits | array | `["AskReddit"]` | Subreddit names to scrape. `r/` prefix optional. **Required.** |
| `sort` | Sort | string | `hot` | `new`, `hot`, `top`, `rising`, `controversial` |
| `time` | Time range | string | `all` | `hour`, `day`, `week`, `month`, `year`, `all` (for Top/Controversial) |
| `includeSelftext` | Include post text | boolean | `true` | Fetch each post's body text |
| `includeMedia` | Include media URLs | boolean | `false` | Extract image/video URLs |
| `includeNSFW` | Include NSFW | boolean | `false` | Include posts flagged over-18 |
| `postDateLimit` | Only posts on/after | string | — | `YYYY-MM-DD`; keep posts on/after this date |
| `searchTerms` | Keyword filter | array | — | Keep only posts matching at least one word |
| `maxItems` | Max items | integer | `50` | Hard cap on posts saved (1–100) |
| `maxPostsPerSource` | Max posts per subreddit | integer | `25` | Cap per subreddit (1–100) |
| `maxPages` | Max listing pages | integer | `1` | Pagination depth per subreddit, 25 posts/page (1–20) |
| `maxRetries` | Max request retries | integer | `3` | Retry attempts per failed request (0–6) |
| `requestDelayMs` | Delay between requests (ms) | integer | `300` | Politeness delay (0–10000) |
| `debug` | Debug logging | boolean | `false` | Emit verbose logs |

***

### Limiting results {#limiting-results}

Three inputs control how many posts you scrape and how deep the actor goes:

- **`maxItems`** (default `50`, max `100`) — a hard cap on the total number of posts saved across the whole run. This is your master limit.
- **`maxPostsPerSource`** (default `25`, max `100`) — caps how many posts are kept from each subreddit, so a single busy community can't crowd out the rest of your list.
- **`maxPages`** (default `1`, max `20`) — how many listing pages to walk per subreddit. Each page holds ~25 posts. Increase this to reach further back in a subreddit's feed.

> **Run duration:** a single run lasts at most ~10 minutes, and only one long-running job runs at a time. For very large jobs, split your subreddits across multiple runs or schedule them.

You can further narrow the posts you scrape without wasting items using `searchTerms` (keyword match), `postDateLimit` (date cutoff), and `includeNSFW` (exclude/include over-18 posts).

***

### Output example {#output-example}

A single dataset item as returned when you scrape a subreddit:

```json
{
  "id": "t3_1v1gas0",
  "url": "https://www.reddit.com/r/forhire/comments/1v1gas0/for_hire_im_a_wordpresswoocommerce_shopify/",
  "nsfw": false,
  "type": "post",
  "flair": "For Hire",
  "score": 1,
  "title": "[FOR HIRE] I'm a WordPress/WooCommerce & Shopify Developer - $20/hr",
  "author": "kalsorop",
  "domain": "self.forhire",
  "edited": false,
  "gilded": 0,
  "isSelf": true,
  "spoiler": false,
  "archived": false,
  "selftext": "Is your online store getting traffic but not enough sales? I'm a Shopify & WordPress/WooCommerce expert with 7+ years of experience helping businesses build, optimize, and scale high-performing online stores...",
  "stickied": false,
  "scrapedAt": "2026-07-20T09:19:31.983Z",
  "subreddit": "forhire",
  "thumbnail": "",
  "createdUtc": "2026-07-20T09:10:59.000Z",
  "sourceType": "reddit",
  "numComments": 1,
  "outboundUrl": "",
  "upvoteRatio": 1,
  "createdUtcEpoch": 1784538659
}
```

***

### How much does scraping a subreddit cost? {#how-much-does-scraping-a-subreddit-cost}

This actor uses simple, predictable **pay-per-result** pricing — you pay for the posts you scrape, not for time or complicated compute units. Runs are efficient and capped at ~10 minutes each, so costs stay low and easy to forecast.

- Small monitoring jobs (a handful of posts) cost only a few cents.
- Larger batches scale linearly with the number of posts you scrape.
- No hidden proxy fees, no separate API subscription, no Reddit developer account.

Check the live pricing on the actor's Apify page. New Apify accounts include free monthly usage credits, so you can **get your first results free in under 2 minutes** at no cost.

***

### Integrate with n8n, Zapier, and Make {#integrations}

Run the actor from anywhere over the Apify API to scrape subreddit posts on a schedule. Use the actor path `myagizm~reddit-subreddit-scraper-v2`.

#### Run synchronously and get dataset items

Best for smaller jobs — start the run and receive the scraped results in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/myagizm~reddit-subreddit-scraper-v2/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "subreddits": ["technology"],
    "sort": "top",
    "time": "week",
    "maxItems": 50
  }'
```

#### Run asynchronously

Start a run and poll or use a webhook for larger jobs:

```bash
curl -X POST "https://api.apify.com/v2/acts/myagizm~reddit-subreddit-scraper-v2/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "subreddits": ["news", "worldnews"],
    "sort": "hot",
    "maxItems": 100
  }'
```

Then fetch the scraped results once the run finishes:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_APIFY_TOKEN&format=json"
```

The actor plugs straight into **n8n**, **Zapier**, **Make**, **Google Sheets**, **Airtable**, **Slack**, and **Notion** via their Apify connectors or plain HTTP — no glue code required. Combine it with webhooks to push newly scraped posts into your stack automatically.

***

### Support {#support}

Questions, feature requests, or a subreddit that won't scrape? Open an **Issue** on the actor's Apify page and include your input configuration so it can be reproduced quickly. Feedback and suggestions are welcome and help shape future updates.

***

### FAQ — scraping a subreddit {#faq}

#### Do I need a Reddit account or API key to scrape a subreddit?

No. There is no login, no OAuth, and no API key — no cookies or account required. Just enter subreddit names and scrape.

#### Is it legal to scrape a subreddit?

The actor collects only **publicly available data** — posts anyone can view without logging in. You are responsible for using the scraped data in line with applicable laws, including GDPR and other privacy regulations, and Reddit's terms. Avoid collecting or processing personal data unlawfully.

#### Can I use Reddit Subreddit Scraper V2 with the Apify API?

Yes. Start runs and fetch datasets over the Apify API using the actor path `myagizm~reddit-subreddit-scraper-v2`, synchronously or asynchronously, from any language or tool.

#### Can I scrape a subreddit through an MCP server with AI agents?

Yes. It works with the Apify MCP server, so Claude, ChatGPT/Codex, and Cursor can run it as a tool and read the structured results directly.

#### Do I need proxies to scrape a subreddit?

No. Proxy handling is built in — you don't configure or pay for anything extra.

#### Can I integrate scraped subreddit data with other apps?

Yes. Connect the actor to Make, Zapier, n8n, Slack, Google Sheets, Airtable, Notion, and more via Apify connectors, webhooks, or plain HTTP.

#### How current is the data?

V2 reads from a cached source, so results may lag up to ~1.5 hours behind the live site. For real-time results, use the V1 subreddit actor or **[Reddit Scraper V2](https://apify.com/myagizm/reddit-scraper-v2)**.

#### How many posts can I scrape in one run?

Up to `maxItems` posts (max 100), capped further by `maxPostsPerSource` and `maxPages`. A single run lasts at most ~10 minutes. For more, split across runs or schedule them.

#### Can I scrape multiple subreddits at once?

Yes. Add as many subreddit names as you like to the `subreddits` list and use `maxPostsPerSource` to keep the dataset balanced.

#### Can I scrape the full text of each post?

Yes — keep `includeSelftext` on (the default) and each self post's body is returned in the `selftext` field.

#### Can I filter the posts I scrape by keyword?

Yes. Use `searchTerms` to keep only posts whose title or text contains at least one of your words.

#### Can I limit to recent posts only?

Yes. Set `postDateLimit` to a `YYYY-MM-DD` date to keep only posts created on or after that date, and use `sort: "new"` with a `time` window for Top/Controversial.

#### Can I export scraped data to CSV, Excel, or JSON?

Yes. After a run, use the **Export** button on the dataset and choose JSON, CSV, Excel, XML, HTML, or RSS — or fetch any format via the API.

#### Does it include NSFW posts?

Only if you enable `includeNSFW`. By default, over-18 posts are excluded.

#### Can I scrape images and videos from a subreddit?

Enable `includeMedia` to capture image and video URLs, including galleries and `v.redd.it` / `i.redd.it` links.

#### Can I schedule the scraper to run automatically?

Yes. Use Apify **Schedules** to run the actor on any cron interval and push newly scraped posts to your stack via webhooks or integrations.

#### Can I scrape a private or banned subreddit?

No. Private, quarantined, or banned subreddits cannot be scraped since their posts aren't publicly viewable. Only public subreddits are supported.

***

### Want other Reddit data? {#want-other-reddit-data}

Reddit Subreddit Scraper V2 is part of a full family of **Reddit V2 scrapers** by myagizm. If you need to scrape something else from Reddit, pick the right tool for the job:

- **[Reddit Scraper V2](https://apify.com/myagizm/reddit-scraper-v2)** — all-in-one Reddit scraper for posts, comments, and subreddits from any URL.
- **[Reddit Comment Scraper V2](https://apify.com/myagizm/reddit-comment-scraper-v2)** — scrape full comment threads from any Reddit post.
- **[Reddit Search Scraper V2](https://apify.com/myagizm/reddit-search-scraper-v2)** — search and scrape Reddit by keyword across all of Reddit.
- **[Reddit Profile Scraper V2](https://apify.com/myagizm/reddit-profile-scraper-v2)** — scrape a user's posts and comment history.
- **[Reddit Community Scraper V2](https://apify.com/myagizm/reddit-community-scraper-v2)** — scrape subreddit metadata, rules, and community stats.

***

### Related searches {#related-searches}

subreddit scraper · scrape subreddit posts · reddit top posts export · monitor subreddit · subreddit data csv · reddit hot posts scraper · reddit new posts monitor · subreddit archive tool · reddit niche research · reddit job posts scraper · scrape subreddit without login

***

### Disclaimer

This is an independent tool and is not affiliated with, endorsed by, or sponsored by Reddit. All product names, logos, and brands are property of their respective owners. Use this actor to scrape only publicly available data and in compliance with all applicable laws and platform terms.

***

### Resources {#resources}

- [Apify API documentation](https://docs.apify.com/api/v2)
- [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) — connect Claude, ChatGPT & Cursor
- [Exporting datasets (JSON, CSV, Excel)](https://docs.apify.com/platform/storage/dataset)
- [Scheduling actors](https://docs.apify.com/platform/schedules)
- [Actor input schema](https://apify.com/myagizm/reddit-subreddit-scraper-v2/input-schema)

***

## 中文说明 —— Reddit 子版块抓取工具（V2）

> **V2 = 托管交付线。** 本 Actor 为 V2：运行在托管基础设施上，交付更稳定、字段更全。若只需要最低价的尽力而为版本，同一功能的 **V1** 版本也在 [商店主页](https://apify.com/myagizm)。

**免登录抓取 Reddit 公开数据** —— 按子版块抓取帖子列表（可含正文与媒体）。不需要 Reddit API Key、不需要 OAuth 应用、不需要登录或 Cookie。结果可导出为 JSON、CSV、Excel、XML，也可通过 Apify API 定时运行并接入 n8n、Zapier、Make 等工具。

> **两分钟内免费拿到第一批数据** —— 填入内容、点击 Start 即可。无需配置，试用不需要信用卡。

### 能做什么

- 📥 **按子版块抓取帖子**，一次可多个版块。
- 🔀 **排序**：`hot` / `new` / `top` / `rising` / `controversial`，配合时间范围。
- 📝 **可选帖子正文**（`includeSelftext`）与**媒体链接**（`includeMedia`）。
- 🔎 **站内关键词过滤**（`searchTerms`）。
- 🗓️ **日期截断**（`postDateLimit`）。
- 📌 **置顶、剧透、NSFW、归档、编辑**等状态标记齐全。
- 📏 **`maxItems` / `maxPostsPerSource` / `maxPages`** 控制深度与成本。

### 谁在用

- 📊 **市场研究** —— 持续监测一个垂直社区的话题走向。
- 🧠 **内容团队** —— 从高赞帖子里找选题。
- 💼 **招聘与自由职业者** —— 盯住招聘类版块的新帖。
- 🏢 **品牌团队** —— 跟踪与自身相关版块的讨论。
- 🧑‍💻 **数据团队** —— 构建按版块划分的帖子数据集。

### 可以抓取哪些数据

| 字段 | 类型 | 说明 |
|------|------|------|
| `id` | string | 记录 ID（帖子如 `t3_...`，评论如 `t1_...`） |
| `url` | string | 永久链接 |
| `type` | string | 记录类型（`post` / `comment` / `user` / `community`） |
| `title` | string | 帖子标题 |
| `author` | string | 作者用户名 |
| `subreddit` | string | 所属子版块 |
| `flair` | string | 帖子 flair 标签 |
| `score` | integer | 抓取时的净赞数 |
| `upvoteRatio` | number | 赞同比例（0–1） |
| `numComments` | integer | 评论数 |
| `selftext` | string | 帖子正文（开启 *Include post text* 时返回） |
| `isSelf` | boolean | 是否为纯文本自帖 |
| `domain` | string | 来源域名（如 `self.AskReddit`、`i.redd.it`） |
| `outboundUrl` | string | 帖子指向的链接（外链帖为外部地址，自帖为永久链接） |
| `thumbnail` | string | 缩略图地址 |
| `nsfw` | boolean | 是否标记为成人内容 |
| `spoiler` | boolean | 是否标记为剧透 |
| `stickied` | boolean | 是否在版块内置顶 |
| `archived` | boolean | 是否已归档 |
| `edited` | boolean | 是否被编辑过 |
| `gilded` | integer | 是否获得奖励 |
| `createdUtc` | string | 创建时间（ISO 8601，UTC） |
| `createdUtcEpoch` | integer | 创建时间（Unix 时间戳） |
| `scrapedAt` | string | 该行的抓取时间（ISO 8601） |
| `sourceType` | string | 该行的采集方式（如 `listing`） |

> 字段取决于该条目公开了什么；不存在的值返回 `null`，数据结构保持稳定。

### 输入示例

```json
{
  "subreddits": ["AskReddit"],
  "sort": "hot",
  "maxItems": 50
}
```

### 输出示例

```json
{
  "id": "t3_1v1gas0",
  "url": "https://www.reddit.com/r/forhire/comments/1v1gas0/for_hire_im_a_wordpresswoocommerce_shopify/",
  "nsfw": false,
  "type": "post",
  "flair": "For Hire",
  "score": 1,
  "title": "[FOR HIRE] I'm a WordPress/WooCommerce & Shopify Developer - $20/hr",
  "author": "kalsorop",
  "domain": "self.forhire",
  "edited": false,
  "gilded": 0,
  "isSelf": true,
  "spoiler": false,
  "archived": false,
  "selftext": "Is your online store getting traffic but not enough sales? I'm a Shopify & WordPress/WooCommerce expert with 7+ years of experience helping businesses build, optimize, and scale high-performing online stores...",
  "stickied": false,
  "scrapedAt": "2026-07-20T09:19:31.983Z",
  "subreddit": "forhire",
  "thumbnail": "",
  "createdUtc": "2026-07-20T09:10:59.000Z",
  "sourceType": "reddit",
  "numComments": 1,
  "outboundUrl": "",
  "upvoteRatio": 1,
  "createdUtcEpoch": 1784538659
}
```

### 价格

采用**按结果计费**：只为真正拿到的数据付费，不按运行时间收费。

- 💸 成本 = 结果数量 × 单价，预算可提前算清。
- 📉 Apify 的 Bronze / Silver / Gold / Platinum / Diamond 套餐享阶梯折扣。
- 🆓 新账号自带每月免费额度，第一次运行不花钱。
- 🚫 无代理附加费、无单次请求费、无最低消费。

实时价格见 [Apify 商店页面](https://apify.com/myagizm/reddit-subreddit-scraper-v2)。

### 使用建议

- 🔀 **`top` + `time` 做对标，`new` 做监控**。
- 🗓️ 监控用 `postDateLimit`，比拉大 limit 更省。
- 📌 时间序列分析时注意排除 `stickied` 置顶帖。
- 🆔 定时运行按 `id` 去重实现增量。
- 📏 每个版块单独设 `maxPostsPerSource`，避免一个热门版吃掉全部额度。

### 其他 Reddit 数据

- 🤖 **[Reddit 综合抓取](https://apify.com/myagizm/reddit-scraper-v2)** —— 子版块 / 用户 / 社区 / 搜索四合一。
- 🔎 **[Reddit 搜索抓取](https://apify.com/myagizm/reddit-search-scraper-v2)** —— 全站或指定版块关键词搜索。
- 🏘️ **[子版块抓取](https://apify.com/myagizm/reddit-subreddit-scraper-v2)** —— 按版块抓帖子。
- 💬 **[评论抓取](https://apify.com/myagizm/reddit-comment-scraper-v2)** —— 可控深度的评论采集。
- 📇 **[社区信息抓取](https://apify.com/myagizm/reddit-community-scraper-v2)** —— 版块规模与简介。
- 👤 **[用户资料抓取](https://apify.com/myagizm/reddit-profile-scraper-v2)** —— karma、账号年龄、徽章。

其他平台同样采用免登录、按结果计费的方式：**[Instagram](https://apify.com/myagizm/instagram-profile-scraper-v2)** ·
**[TikTok](https://apify.com/myagizm/tiktok-profile-scraper-v2)** · **[X（推特）](https://apify.com/myagizm/x-tweets-scraper)** ·
**[LinkedIn](https://apify.com/myagizm/linkedin-profile-scraper)** · **[YouTube](https://apify.com/myagizm/youtube-channel-scraper)** ·
**[Google 地图](https://apify.com/myagizm/google-maps-scraper)**。完整工具家族见 **[myagizm 商店主页](https://apify.com/myagizm)**。

### 配合 AI 智能体使用（MCP）

本 Actor 已接入 **Apify MCP 服务器**，Claude、ChatGPT、Cursor 等助手可以把它当作工具直接调用，用自然语言提问即可拿到结构化结果，无需写胶水代码。

### 集成与 API

支持 **Make、Zapier、n8n、Slack、Airbyte、Gumloop、CrewAI、IFTTT、Lindy、GitHub、Google Sheets、Google Drive**，以及 Webhook、定时任务与 MCP 服务器。

```bash
curl -X POST "https://api.apify.com/v2/acts/myagizm~reddit-subreddit-scraper-v2/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
  "subreddits": ["AskReddit"],
  "sort": "hot",
  "maxItems": 50
}'
```

把 `format` 改成 `json`、`csv`、`xlsx` 或 `xml` 即可导出不同格式。

### 常见问题

**需要 Reddit API Key 或登录吗？**
不需要。没有 API Key、没有 OAuth 应用、不登录、不用 Cookie。

**抓取 Reddit 合法吗？**
只采集公开可见的数据，即任何未登录访客都能看到的内容。不登录、不访问私密版块或私信。合规责任由使用者承担：如涉及个人数据请遵守 GDPR / CCPA 与平台条款。

**能抓私密版块或已删除内容吗？**
不能，会被跳过并记录在运行日志中。

**需要配置代理吗？**
不需要，已内置托管。

**支持导出 CSV / Excel / JSON 吗？**
支持 JSON、CSV、Excel、XML。

**可以通过 Apify API 调用吗？**
可以，见上方示例。

**支持 AI 智能体（MCP）吗？**
支持，Claude、ChatGPT、Cursor 均可当作工具调用。

**可以定时运行吗？**
可以，支持 Apify Schedules、API 与 Webhook；按 `id` 去重即可实现增量采集。

**V1 和 V2 有什么区别？**
V1 轻量自包含、价格最低、尽力而为；V2 运行在托管基础设施上，交付更稳定、字段更全。两者输入基本一致，可以先用 V1 广筛、再用 V2 精查。

**数据有多新？**
不缓存，每次运行都读取当前公开页面。

### 免责声明

本工具为独立第三方工具，与 Reddit, Inc. 无任何隶属、认可或赞助关系，所有商标归各自所有者。

本 Actor 只采集**公开可见**的数据，不登录、不绕过访问控制、不获取私密内容。数据使用的合规责任由使用者承担。

### 相关搜索

子版块抓取 · reddit 版块帖子导出 · reddit 帖子监控 · reddit 热帖抓取 · 免登录抓取子版块 · reddit 版块数据 csv · reddit 选题挖掘 · reddit 招聘帖监控

# Actor input Schema

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

Subreddit names to scrape posts from, e.g. "AskReddit", "news". The r/ prefix is optional (both "forhire" and "r/forhire" work).

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

Listing order for the subreddit feed. For example, choose "top" to get the highest-scoring posts, or "new" for the most recent.

## `time` (type: `string`):

Time window applied to Top / Controversial sorts. For example, pick "week" to get the top posts of the past 7 days.

## `includeSelftext` (type: `boolean`):

Fetch each post's self/body text. For example, enable this to capture the full "\[FOR HIRE]" description on r/forhire posts for lead generation.

## `includeMedia` (type: `boolean`):

Extract image/video URLs (i.redd.it, v.redd.it, imgur, galleries). For example, enable this when scraping r/pics to collect every image link alongside the post.

## `includeNSFW` (type: `boolean`):

Include posts flagged over-18 / NSFW. For example, leave this off to keep the dataset safe-for-work, or turn it on for complete community coverage.

## `postDateLimit` (type: `string`):

Keep only posts created on or after this date. Leave empty for no limit. For example, "2026-01-01" keeps only posts from 2026 onward.

## `searchTerms` (type: `array`):

Keep only posts whose title or text contains at least one of these words. For example, \["hiring", "developer"] keeps only posts mentioning either word.

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

Hard cap on the total posts saved across the whole run. For example, set 50 for a quick monitoring pull. A run lasts at most ~10 minutes.

## `maxPostsPerSource` (type: `integer`):

Cap on posts kept from each subreddit, so one busy community can't dominate. For example, set 25 when scraping 4 subreddits to get a balanced 100-post dataset.

## `maxPages` (type: `integer`):

Pagination depth per subreddit (25 posts/page). For example, set 5 to reach ~125 posts back into a subreddit's feed.

## `maxRetries` (type: `integer`):

Retry attempts per failed request. For example, raise to 5 for flaky network conditions; lower to 0 for the fastest possible run.

## `requestDelayMs` (type: `integer`):

Politeness delay between requests, in milliseconds. For example, 300 is a good default; raise to 1000 to be gentler on large jobs.

## `debug` (type: `boolean`):

Emit verbose logs. For example, enable this to diagnose why a specific subreddit returns no posts.

## Actor input object example

```json
{
  "subreddits": [
    "news",
    "technology"
  ],
  "sort": "hot",
  "time": "week",
  "includeSelftext": true,
  "includeMedia": false,
  "includeNSFW": false,
  "postDateLimit": "2026-01-01",
  "searchTerms": [
    "hiring",
    "release"
  ],
  "maxItems": 50,
  "maxPostsPerSource": 25,
  "maxPages": 1,
  "maxRetries": 3,
  "requestDelayMs": 300,
  "debug": false
}
```

# Actor output Schema

## `results` (type: `string`):

All scraped items as structured JSON.

# 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": [
        "AskReddit"
    ],
    "sort": "hot",
    "time": "week",
    "includeSelftext": true,
    "includeMedia": false,
    "includeNSFW": false,
    "maxItems": 50,
    "maxPostsPerSource": 25,
    "maxPages": 1,
    "maxRetries": 3,
    "requestDelayMs": 300,
    "debug": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("myagizm/reddit-subreddit-scraper-v2").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": ["AskReddit"],
    "sort": "hot",
    "time": "week",
    "includeSelftext": True,
    "includeMedia": False,
    "includeNSFW": False,
    "maxItems": 50,
    "maxPostsPerSource": 25,
    "maxPages": 1,
    "maxRetries": 3,
    "requestDelayMs": 300,
    "debug": False,
}

# Run the Actor and wait for it to finish
run = client.actor("myagizm/reddit-subreddit-scraper-v2").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": [
    "AskReddit"
  ],
  "sort": "hot",
  "time": "week",
  "includeSelftext": true,
  "includeMedia": false,
  "includeNSFW": false,
  "maxItems": 50,
  "maxPostsPerSource": 25,
  "maxPages": 1,
  "maxRetries": 3,
  "requestDelayMs": 300,
  "debug": false
}' |
apify call myagizm/reddit-subreddit-scraper-v2 --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Subreddit Scraper V2",
        "description": "Reddit Subreddit Scraper V2 — cached data source (results may lag up to ~1.5h). Structured JSON, no login, no API key. For real-time data use the V1 actor.",
        "version": "0.1",
        "x-build-id": "tEYCK3wO5SqoBSdmC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/myagizm~reddit-subreddit-scraper-v2/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-myagizm-reddit-subreddit-scraper-v2",
                "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/myagizm~reddit-subreddit-scraper-v2/runs": {
            "post": {
                "operationId": "runs-sync-myagizm-reddit-subreddit-scraper-v2",
                "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/myagizm~reddit-subreddit-scraper-v2/run-sync": {
            "post": {
                "operationId": "run-sync-myagizm-reddit-subreddit-scraper-v2",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "subreddits": {
                        "title": "🎯 Subreddits",
                        "type": "array",
                        "description": "Subreddit names to scrape posts from, e.g. \"AskReddit\", \"news\". The r/ prefix is optional (both \"forhire\" and \"r/forhire\" work).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sort": {
                        "title": "↕️ Sort",
                        "enum": [
                            "new",
                            "hot",
                            "top",
                            "rising",
                            "controversial"
                        ],
                        "type": "string",
                        "description": "Listing order for the subreddit feed. For example, choose \"top\" to get the highest-scoring posts, or \"new\" for the most recent.",
                        "default": "hot"
                    },
                    "time": {
                        "title": "📅 Time range",
                        "enum": [
                            "hour",
                            "day",
                            "week",
                            "month",
                            "year",
                            "all"
                        ],
                        "type": "string",
                        "description": "Time window applied to Top / Controversial sorts. For example, pick \"week\" to get the top posts of the past 7 days.",
                        "default": "all"
                    },
                    "includeSelftext": {
                        "title": "💬 Include post text",
                        "type": "boolean",
                        "description": "Fetch each post's self/body text. For example, enable this to capture the full \"[FOR HIRE]\" description on r/forhire posts for lead generation.",
                        "default": true
                    },
                    "includeMedia": {
                        "title": "🖼️ $ Include media URLs",
                        "type": "boolean",
                        "description": "Extract image/video URLs (i.redd.it, v.redd.it, imgur, galleries). For example, enable this when scraping r/pics to collect every image link alongside the post.",
                        "default": false
                    },
                    "includeNSFW": {
                        "title": "🔞 Include NSFW",
                        "type": "boolean",
                        "description": "Include posts flagged over-18 / NSFW. For example, leave this off to keep the dataset safe-for-work, or turn it on for complete community coverage.",
                        "default": false
                    },
                    "postDateLimit": {
                        "title": "📆 Only posts on/after (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Keep only posts created on or after this date. Leave empty for no limit. For example, \"2026-01-01\" keeps only posts from 2026 onward."
                    },
                    "searchTerms": {
                        "title": "🔎 Keyword filter",
                        "type": "array",
                        "description": "Keep only posts whose title or text contains at least one of these words. For example, [\"hiring\", \"developer\"] keeps only posts mentioning either word.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "💯 Max items",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Hard cap on the total posts saved across the whole run. For example, set 50 for a quick monitoring pull. A run lasts at most ~10 minutes.",
                        "default": 50
                    },
                    "maxPostsPerSource": {
                        "title": "💯 Max posts per subreddit",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Cap on posts kept from each subreddit, so one busy community can't dominate. For example, set 25 when scraping 4 subreddits to get a balanced 100-post dataset.",
                        "default": 25
                    },
                    "maxPages": {
                        "title": "📄 Max listing pages",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Pagination depth per subreddit (25 posts/page). For example, set 5 to reach ~125 posts back into a subreddit's feed.",
                        "default": 1
                    },
                    "maxRetries": {
                        "title": "🔁 Max request retries",
                        "minimum": 0,
                        "maximum": 6,
                        "type": "integer",
                        "description": "Retry attempts per failed request. For example, raise to 5 for flaky network conditions; lower to 0 for the fastest possible run.",
                        "default": 3
                    },
                    "requestDelayMs": {
                        "title": "⏱️ Delay between requests (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Politeness delay between requests, in milliseconds. For example, 300 is a good default; raise to 1000 to be gentler on large jobs.",
                        "default": 300
                    },
                    "debug": {
                        "title": "🐞 Debug logging",
                        "type": "boolean",
                        "description": "Emit verbose logs. For example, enable this to diagnose why a specific subreddit returns no posts.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
