# Reddit Community Post (`truefetch/reddit-community-post`) Actor

Reddit community posts and optional comment threads in 53-field records: stable IDs, engagement, state flags, media, polls, galleries, crosspost lineage, and duplicates. Five listing modes, no Reddit API key, and scheduled FREE-tier Result pricing at $5.50 per 1,000.

- **URL**: https://apify.com/truefetch/reddit-community-post.md
- **Developed by:** [TrueFetch](https://apify.com/truefetch) (community)
- **Categories:** Social media, Developer tools, Automation
- **Features:** Limited permissions
- **Stats:** 5 total users, 0 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $4.13 / 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Reddit Community Post

**Reddit Community Post is a reddit posts scraper with comments that turns one subreddit listing into 53-field post records with stable source IDs, text, engagement values, state flags, media, polls, galleries, crosspost lineage, duplicates, provenance, and optional nested comments.**

- **Four required inputs define the subreddit, sort mode, requested post count, and per-post comment count.**
- **Every returned post follows a 53-field top-level dataset contract.**
- **Both numeric inputs have measured lower bounds but no artificial schema maximum; `max_comments: 0` skips comments.**
- **Comments are optional and separately billed**, so a post-only run never pays for discussion it did not ask for.

[**Run the `webdev` hot-listing example**](https://console.apify.com/actors/truefetch~reddit-community-post/input) · [**View API**](https://apify.com/truefetch/reddit-community-post/api)

The smallest configured FREE-tier case costs **$0.01550** for one start and one returned post with no comments. Reddit determines what each listing exposes, and large post/comment combinations can take much longer or exceed a run window. Begin with one post, keep comments disabled, set a maximum total charge, and inspect the source record before scaling.

### What does Reddit Community Post do?

Reddit Community Post reads one of Reddit's standard community listings—`new`, `top`, `hot`, `rising`, or `controversial`—and writes the selected posts to an Apify dataset. Each row preserves the post's community context, source identifiers, text, link, timestamps, source vote values, status flags, media references, duplicate links, and processing time.

When `max_comments` is positive, the post row can also contain a nested array of visible comments. Comment records include their own identifiers, authors, bodies, timestamps, source vote values, parent relationship, `replyLevel`, URL, and state flags.

This is a timestamped source observation, not an exhaustive subreddit archive. It does not classify sentiment, assess factual accuracy, verify authors, determine influence, infer demographics, or prove why Reddit ranked an item. Vote values can be fuzzed, deleted content can be unavailable, and later runs can differ.

### How do I run Reddit Community Post?

Open the [Actor input page](https://apify.com/truefetch/reddit-community-post/input-schema) and use the bounded `webdev` prefill first. It requests two `hot` posts and at most one comment per post, small enough to inspect while exercising both post and comment output. Plain subreddit names are easiest to review, while common r/name paths and standard Reddit community URLs are also accepted.

Use the same bounded example throughout this guide:

```json
{
  "community": "webdev",
  "sort_by": "hot",
  "max_posts": 2,
  "max_comments": 1
}
```

After completion, open the default dataset. Confirm the community, post ID, original link, timestamps, body, source engagement fields, flags, arrays, and processing time. If the row will support a consequential claim, follow its Reddit link and record when the verification occurred.

Increase the post count and comment count separately. That makes changes in duration, output volume, source coverage, and charge easier to understand. The accepted maximum values are validation ceilings, not recommended workload sizes.

### What data does Reddit Community Post return?

The dataset contains 53 top-level fields:

- **Provenance:** `processor`, `processed_at`.
- **Community:** `subreddit`, `subreddit_id`, `subreddit_type`, `subreddit_subscribers`.
- **Post and author:** `id`, `author`, `author_id`, `author_flair`, `created`, `edited`, `url`, `flair_text`, `title`, `body`.
- **Engagement and lineage:** `score`, `score_hidden`, `upvote_ratio`, `comment_count`, `crossposts`, `crosspost_id`, `crosspost_url`, `gilded`, `categories`.
- **Media:** `media_type`, `domain`, `thumbnail`, `images`, `gallery`, `media_url`, `video_url`, `video_duration`, `poll`, `is_self`, `is_video`, `is_gallery`.
- **State and distribution:** `archived`, `locked`, `stickied`, `pinned`, `over_18`, `spoiler`, `original`, `advertising`, `indexable`, `crosspostable`, `removed_by`, `distinguished`, `no_follow`, `ad_whitelist`.
- **Related source records:** `duplicates`, `comments`.

This abbreviated example follows the shared `webdev` scenario. It illustrates the contract rather than promising a future post:

```json
{
  "processor": "https://apify.com/username/actor_name",
  "processed_at": "2026-08-03T08:30:00+00:00",
  "subreddit": "webdev",
  "subreddit_type": "public",
  "subreddit_subscribers": 2800000,
  "id": "example-post",
  "author": "example_author",
  "author_flair": "Frontend Developer",
  "created": "2026-08-03T07:55:00+00:00",
  "url": "https://www.reddit.com/r/webdev/comments/example-post/",
  "title": "How do you review accessibility before release?",
  "score": 184,
  "upvote_ratio": 0.94,
  "comment_count": 37,
  "over_18": false,
  "images": [],
  "duplicates": [],
  "comments": []
}
```

Reddit can fuzz vote-related values, so `score` should not be treated as audited arithmetic. `score_hidden` reports whether the source currently hides that value; it does not imply a score of zero.

A nested comment can expose 16 keys: `id`, `isRoot`, `created`, `edited`, `author`, `author_flair`, `body`, `score`, `archived`, `locked`, `stickied`, `submitter`, `parentId`, `replyLevel`, `url`, and optional `media_url`. Deleted, collapsed, unavailable, or unexpanded comments can be absent.

### What inputs can I configure?

`community` is required and must be a non-empty string. Accepted common forms include `apify`, `r/apify`, `/r/apify`, and a standard Reddit URL containing `/r/apify`.

`sort_by` is required. Choose `new`, `top`, `hot`, `rising`, or `controversial`. Those names refer to Reddit listing behavior; they do not define a complete or stable historical ordering.

`max_posts` is required, accepts integers from 1 upward, and has no schema maximum. It caps the number requested, but Reddit normally stops one listing near a thousand entries and can return fewer.

`max_comments` is required, accepts integers from 0 upward, and has no schema maximum. Use 0 to skip comments. A positive limit does not guarantee an equal number of nested records, and large trees may exceed a run window.

There are no inputs for time range, keyword, flair, author, score, media type, language, geography, or adult-content exclusion. Apply those conditions after export and include source context when interpreting the filtered set.

### What platforms and markets does Reddit Community Post cover?

The Actor covers subreddit posts and visible comments exposed by Reddit. It does not combine data from Telegram, Discord, X, forums, news sites, or other networks, and it does not attempt cross-platform identity matching.

There is no country selector. A subreddit, language, post time, flair, author description, or engagement value is not proof of the author's location, age, profession, affiliation, or demographic characteristics. Private, banned, quarantined, restricted, renamed, or unavailable communities can reduce or prevent coverage.

Results reflect the source state at processing time. A later absence does not by itself prove deletion, moderation, or policy action.

### Why use Reddit Community Post?

The Actor provides a repeatable dataset contract without asking users to supply Reddit client credentials. It works through Apify Console for manual runs and through API, schedules, webhooks, and MCP for approved automations.

The unified post row reduces the mapping needed to combine text, links, community context, status flags, and source engagement fields. Optional nested comments keep the discussion attached to its parent post, while the processing fields preserve when and where the record was produced.

Exports are available through Apify-supported formats such as JSON, JSONL, CSV, Excel, XML, and dataset API access. For reliable downstream work, preserve nulls and empty arrays rather than replacing them with assumptions.

### Who is Reddit Community Post for?

**Researchers** can capture bounded source samples for qualitative review, topic exploration, or reproducible observation. They should explain the chosen listing and avoid generalizing it to the complete community.

**Developer teams** can integrate post rows into storage, review, alerting, enrichment, or approved NLP pipelines. A stable top-level contract makes field mapping explicit, but source uncertainty still needs handling.

**Community and content teams** can monitor recent public discussions or compare visible themes. Scores and comments must not be used as automatic evidence of quality, consensus, safety, or author intent.

**AI-agent builders** can request a small current sample through MCP. Agents should cite original links, processing timestamps, input choices, and the fact that the selected Reddit listing is incomplete and changeable.

### How can I use Reddit Community Post through the API or MCP?

The synchronous HTTP example below uses the shared `webdev`/`hot`/two-post scenario. Replace `YOUR_TOKEN` with a secret-managed Apify token:

```bash
curl -X POST "https://api.apify.com/v2/acts/ArH4ExWA6fVhpwgqD/run-sync-get-dataset-items" \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"community":"webdev","sort_by":"hot","max_posts":2,"max_comments":1}'
```

For MCP, follow the [Apify MCP documentation](https://docs.apify.com/integrations/mcp) and configure the service endpoint:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?token=YOUR_TOKEN"
    }
  }
}
```

Then address this Actor with the same bounded input:

```json
{
  "actor": "truefetch/reddit-community-post",
  "input": {
    "community": "webdev",
    "sort_by": "hot",
    "max_posts": 2,
    "max_comments": 1
  }
}
```

For larger jobs, start asynchronously, poll the run, and retrieve the default dataset after success. A synchronous client can time out before the cloud run ends. Protect tokens, define independent spending limits, and avoid automatically retrying a large paid input without checking the original run.

### How much does Reddit Community Post cost?

The accepted pricing record switches `Post` to `Result` at **2026-08-17 12:15:26.948 UTC**; `Comment` remains one event per retained nested comment. Before that timestamp, consult the live Store page for the current Post event and price. The scheduled record is:

| Tier | Actor start | Result per post | Comment |
| --- | ---: | ---: | ---: |
| FREE | $0.01000 | $0.00550 | $0.00125 |
| BRONZE | $0.01000 | $0.00495 | $0.00113 |
| SILVER | $0.01000 | $0.00440 | $0.00100 |
| GOLD | $0.01000 | $0.00413 | $0.00094 |
| PLATINUM | $0.01000 | $0.00413 | $0.00094 |
| DIAMOND | $0.01000 | $0.00413 | $0.00094 |

The smallest useful FREE-tier test is one returned post with comments set to zero: **$0.01000 + 1 × $0.00550 = $0.01550**.

Actual charges follow emitted posts and charged comments under live platform behavior and account settings. Published prices can change, so inspect the live pricing page before budgeting. `max_posts` and `max_comments` constrain requested output shape but do not substitute for `maxTotalChargeUsd`.

### How does Reddit Community Post compare with alternatives?

| Approach | Useful when | Main tradeoff |
| --- | --- | --- |
| Reddit Community Post | You need structured subreddit posts plus optional nested comments and Apify integrations | Listings and fields remain source-dependent; large combinations can be slow |
| Manual Reddit review | You need deep context for a handful of posts | Difficult to reproduce and export consistently |
| Custom Reddit integration | You require custom filtering, concurrency, storage, or recovery rules | Requires credentials, engineering, monitoring, and maintenance |
| Search-only post collection | You know keywords but not necessarily a single community | Different discovery scope and possible loss of community-listing context |

Choose the method that matches the research question. A standard listing is suitable for bounded source observation, not for claims of exhaustive historical coverage.

### What are the limits and troubleshooting steps?

Post and comment limits can multiply. A request for many posts with many comments creates far more source work than either number alone suggests, and comment-tree expansion can cost time even when the final nested array is small. Use one post and zero comments as the diagnostic baseline.

If validation fails, provide all four required inputs and ensure the sort value is supported. If no posts are returned, verify the community and retry a minimal `new` request; a source error can resemble an empty listing. If a run is slow, reduce both limits and inspect cloud status before retrying.

Null fields, zero values, and empty arrays should be retained. They can reflect post type, account-relative state, disabled comments, unavailable source data, or no returned values. They do not justify filling in a guessed answer.

### Frequently asked questions

#### How do I scrape Reddit posts and full comment threads?

To scrape Reddit posts and full comment threads, set `max_posts` for the listing and raise `max_comments` above zero; each post row then carries its nested comment array alongside the 53 top-level fields.

#### Is this a Reddit API alternative for posts?

Yes — it works as a Reddit API alternative for posts: no app registration or API key is required from you, and the listing arrives as structured dataset rows instead of raw endpoint responses.

#### Is max_comments required?

Yes. Set `max_comments` to `0` for posts without nested comments; use a small positive integer only when you need thread data, then scale after measuring the run.

#### Are top, hot, and controversial complete rankings?

No. They are source listings controlled by Reddit and can change. The Actor does not add a separate time-window input.

#### Why might fewer posts or comments be returned?

Availability, deletions, community state, listing coverage, comment visibility, source failures, charging, and runtime can all reduce output.

#### Can vote values be used as exact totals?

No. Treat them as source-reported signals that may be fuzzed, not audited counts or proof of community consensus.

#### Does the Actor verify post content or authors?

No. It structures public source data and provides links for review; it does not authenticate identities or validate factual claims.

### Related TrueFetch Actors

- [Reddit Search API](https://apify.com/truefetch/reddit-search-api) discovers posts from a query rather than one community listing.
- [Reddit User Profile](https://apify.com/truefetch/reddit-user-profile) enriches a known Reddit username with public profile data.
- [Reddit Community Profile](https://apify.com/truefetch/reddit-community-profile) returns one subreddit's metadata, rules, settings, and source metrics.

### Support

For a reproducible issue, open an [Issue](https://apify.com/truefetch/reddit-community-post/issues) or contact the [TrueFetch group](https://t.me/TrueFetch). Include the Actor name, run ID, sanitized input, expected behavior, and observed outcome. Never publish tokens, credentials, private datasets, or unnecessary personal information.

Use Reddit data proportionately and follow platform terms, applicable law, privacy obligations, and organizational policies. Do not use the output for harassment, spam, sensitive profiling, or automated decisions requiring verified identity. The [Actor page](https://apify.com/truefetch/reddit-community-post) shows the live release and pricing.

- [Store page](https://apify.com/truefetch/reddit-community-post)
- [API reference](https://apify.com/truefetch/reddit-community-post/api)
- [Input configuration](https://apify.com/truefetch/reddit-community-post/input)
- [Pricing](https://apify.com/truefetch/reddit-community-post/pricing)
- [Report an issue](https://apify.com/truefetch/reddit-community-post/issues)
- [TrueFetch community](https://t.me/TrueFetch)

[**Run the `webdev` hot-listing example**](https://console.apify.com/actors/truefetch~reddit-community-post/input) · [**View API**](https://apify.com/truefetch/reddit-community-post/api)

**Last Updated:** August 15, 2026

# Actor input Schema

## `community` (type: `string`):

Subreddit name, r/name path, or reddit.com/r/name URL. Example: 'apify'

## `sort_by` (type: `string`):

Listing order: new, top, hot, rising, or controversial. Reddit determines the available order and coverage.

## `max_posts` (type: `integer`):

Posts to return, minimum 1 and no upper limit. Reddit stops a subreddit listing near 1,000 entries whatever limit is asked for — measured on communities from a few hundred to millions of members — so asking for more returns everything it will serve.

## `max_comments` (type: `integer`):

Comments per post, minimum 0 and no upper limit. A comment tree returns about 450 in one read and names the rest, which this actor then resolves in bounded rounds. Set 0 to skip comments entirely.

## Actor input object example

```json
{
  "community": "webdev",
  "sort_by": "hot",
  "max_posts": 2,
  "max_comments": 1
}
```

# Actor output Schema

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

Reddit post records in the default dataset, including optional charged nested comments.

# 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 = {
    "community": "webdev",
    "sort_by": "hot",
    "max_posts": 2,
    "max_comments": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("truefetch/reddit-community-post").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 = {
    "community": "webdev",
    "sort_by": "hot",
    "max_posts": 2,
    "max_comments": 1,
}

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

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

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

```

## CLI example

```bash
echo '{
  "community": "webdev",
  "sort_by": "hot",
  "max_posts": 2,
  "max_comments": 1
}' |
apify call truefetch/reddit-community-post --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,truefetch/reddit-community-post"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/ArH4ExWA6fVhpwgqD/builds/9mMLBwGInNQ13mx5P/openapi.json