# Reddit Data Engine for Claude (MCP) (`practicaltools/reddit-claude-connector`) Actor

The dedicated data Actor behind the Reddit Research Claude connector. Search Reddit,
browse subreddits, pull posts with comments, and look up user profiles, reserved
capacity so Claude's requests never queue behind bulk scraping jobs.

- **URL**: https://apify.com/practicaltools/reddit-claude-connector.md
- **Developed by:** [Practical Tools](https://apify.com/practicaltools) (community)
- **Categories:** AI, Social media, MCP servers
- **Features:** Limited permissions, Single-tenant, Server interface
- **Stats:** 6 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 item prices

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

Learn more: https://docs.apify.com/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 Research for Claude — MCP Connector Actor

practicaltools/reddit-claude-connector

This Actor is the dedicated data engine behind the
[Reddit Research Claude connector](https://redditmcp.practical.tools) — an MCP server
that lets Claude search Reddit, browse subreddits, read posts with comments, and look
up user profiles, using Reddit's official OAuth2 API (no end-user login required).

⚠️ **Looking for the cheapest bulk option instead?** This Actor is reserved for
Claude/agent traffic and priced accordingly. For raw bulk data at the lowest price,
use [Fast Reddit Scraper ($2/1k)](https://apify.com/practicaltools/apify-reddit-api).
For deduplicated lead-gen monitoring, use
[Reddit Keyword Monitor](https://apify.com/practicaltools/reddit-keyword-monitor).

### Why a dedicated Actor for Claude?

Claude connectors need to feel instant — a user asks a question, Claude calls a tool,
and the answer needs to come back inside a single conversational turn. Sharing infra
with high-volume bulk scraping jobs means Claude's requests can end up queued behind
someone else's 50,000-item run.

This Actor exists to avoid that. It runs on capacity reserved for interactive,
agent-driven traffic, kept in lockstep with the
[Reddit Research connector's](https://redditmcp.practical.tools) four tools
(`search_reddit`, `get_subreddit_posts`, `get_post_with_comments`, `get_user_profile`).
Same underlying data and Reddit API access as our other Reddit Actors — the premium
buys reliability and priority, not different data.

### What does this Actor do?

- Scrape subreddits (communities) and get top/new/hot posts
- Extract Reddit posts with title, text, username, number of comments, votes, and media
- Get Reddit comments, timestamps, points, usernames, post and comment URLs
- Scrape user details, their most recent posts, and comments
- Sort scraped data by Relevance, Hot, Top, or New
- Scrape by specific Reddit URLs or by keyword search

### What data can you extract?

- Subreddit details: name, number of members, description, URL
- Reddit posts: title, text, username, votes, media, timestamps
- Reddit comments: body, username, upvotes, timestamps, parent/post info
- User details: profile info, karma, recent posts/comments

### Use it via Claude (recommended)

Most people using this Actor won't call it directly — they'll talk to Claude. Add the
connector once, and Claude handles the rest:

1. In Claude: **Settings → Connectors → Add custom connector**
2. Enter `https://redditmcp.practical.tools/mcp`
3. Paste an Apify API token when prompted (this Actor bills to that token)
4. Ask Claude to research something on Reddit

Full setup docs: [redditmcp.practical.tools](https://redditmcp.practical.tools)

### Using the Actor directly

The Actor also works standalone via the Apify console, API, or CLI, with the same
input schema as our other Reddit Actors.

#### Mode 1: Start URLs (direct scraping)

| URL type | What you get |
| --- | --- |
| `reddit.com/r/python/` | Posts from the subreddit feed + optional community metadata |
| `reddit.com/r/python/comments/abc123/` | That specific post + its comments (with nested replies) |
| `reddit.com/user/someuser/` | User profile + their recent posts |

#### Mode 2: Search Queries

Provide one or more search queries. Each runs independently and searches all of Reddit
by default. Use the search type flags (`searchPosts`, `searchComments`,
`searchCommunities`, `searchUsers`) to control what kinds of results come back. Combine
with a subreddit URL in Start URLs to scope a search to one community instead of all
of Reddit.

#### Example inputs

**Scrape a subreddit feed:**
\`\`\`json
{
"startUrls": \[{ "url": "https://www.reddit.com/r/javascript/" }],
"sort": "hot",
"maxItems": 50,
"skipCommunity": true
}
\`\`\`

**Search for posts and their comments:**
\`\`\`json
{
"searches": \["web scraping"],
"searchPosts": true,
"searchComments": true,
"fetchPostComments": true,
"sort": "relevance",
"time": "month",
"maxItems": 25
}
\`\`\`

### Pricing

**$8.00 per 1,000 results** — posts, comments, users, or communities returned.
Apify's free plan gives every account $5/month of platform credit — **625 results,
free, every month** — so you can fully test the Claude connector before spending
anything.

- No per-run or start fees — you're charged only for what you get back
- Costs scale linearly: 500 results = $4.00, 2,000 results = $16.00
- Priced above our bulk Actor deliberately — this pays for capacity reserved for
  real-time, interactive traffic instead of competing with bulk jobs for the same
  queue

If you're running large one-off bulk exports rather than powering an AI agent, use
[Fast Reddit Scraper ($2/1k)](https://apify.com/practicaltools/apify-reddit-api)
instead — same data, lower price, no reserved-capacity guarantee.

### FAQ

**Is Reddit scraping legal?** Scraping public Reddit data is generally allowed, but
always comply with Reddit's terms of service and use data responsibly.

**Do I need proxies?** No — this uses Reddit's official OAuth2 API, not scraping.

**Why is this pricier than your other Reddit Actor?** It's the same data and the same
underlying API access, running on infrastructure reserved for low-latency, interactive
use — specifically the [Claude connector](https://redditmcp.practical.tools). If price
matters more than latency/reliability guarantees to you, use our other Reddit Actors
instead.

**Can I use this without Claude?** Yes, directly via the Apify console, API, or CLI —
see "Using the Actor directly" above.
\`\`\`

# Actor input Schema

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

Reddit URLs to scrape directly. Supports three URL types:
• Subreddit (e.g. reddit.com/r/python/) — scrapes the subreddit feed
• Post (e.g. reddit.com/r/python/comments/abc123/) — fetches that post and its comments
• User (e.g. reddit.com/user/someuser/) — fetches the user profile and their recent posts

Tip: combine with Search Queries to search within a specific subreddit instead of globally.

## `searches` (type: `array`):

Keywords or phrases to search for on Reddit. Each query runs independently and returns up to Max Items results.

Tip: wrap a query in quotes for exact phrase matching — e.g. '"web scraping"' will only match that exact phrase, while 'web scraping' matches posts containing both words anywhere.

What gets searched depends on the search type flags below. If you also provide a subreddit in Start URLs, the search is scoped to that subreddit. Otherwise it searches all of Reddit.

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

How to order results.

For search queries: relevance (default) gives the best matches; new/top/hot/comments also work.
For subreddit feeds: hot/new/top/controversial/rising. If you pick 'relevance' with a subreddit feed, it falls back to hot.

relevance and comments are only valid for searches, not subreddit feeds.

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

Limits results to posts created within the selected time window. Applies to both subreddit feeds and search queries. Use 'all' to include posts from any time.

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

Maximum number of results per job. Each search query, subreddit, or URL counts as a separate job, so total output can exceed this number when you have multiple inputs.

Example: 2 search queries × maxItems 25 = up to 50 posts total.

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

Include NSFW (Not Safe For Work) content.

## `skipComments` (type: `boolean`):

When scraping a direct post URL, comments are fetched by default. Enable this to get only the post metadata without its comments. Does not affect the 'Fetch Comments for Each Post' option.

## `skipUserPosts` (type: `boolean`):

When scraping a user profile, recent posts are fetched by default alongside profile info. Enable this to get only the profile metadata.

## `skipCommunity` (type: `boolean`):

When scraping a subreddit feed, community metadata (member count, description, etc.) is fetched alongside posts. Enable this to skip that extra request and get only posts.

## `ignorestartUrls` (type: `boolean`):

Forces search-only mode — Start URLs are ignored even if provided. Useful if you have URLs saved in your input but want to run a search-only job without deleting them.

## `searchPosts` (type: `boolean`):

Find posts matching the search keyword. Returns post objects with title, body, upvotes, and comment count. On by default — disable if you only want comments, communities, or users.

## `searchComments` (type: `boolean`):

Find comments matching the search keyword. Works by fetching posts that match the keyword and then filtering their comments — this uses more API calls than post search.

## `fetchPostComments` (type: `boolean`):

When enabled, each post returned from a subreddit or keyword search will include a 'comments' array with its top-level comments. Significantly increases API usage — one extra request per post.

## `searchCommunities` (type: `boolean`):

Find subreddits whose name or description matches the keyword. Returns community objects with member count, description, and URL.

## `searchUsers` (type: `boolean`):

Find Reddit user accounts matching the keyword. Returns user objects with karma, profile info, and account age.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.reddit.com/r/javascript/"
    }
  ],
  "searches": [
    "apify"
  ],
  "sort": "relevance",
  "time": "all",
  "maxItems": 25,
  "includeNSFW": false,
  "skipComments": false,
  "skipUserPosts": false,
  "skipCommunity": true,
  "ignorestartUrls": false,
  "searchPosts": true,
  "searchComments": false,
  "fetchPostComments": false,
  "searchCommunities": false,
  "searchUsers": false
}
```

# 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": [
        {
            "url": "https://www.reddit.com/r/javascript/"
        }
    ],
    "searches": [
        "apify"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("practicaltools/reddit-claude-connector").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": [{ "url": "https://www.reddit.com/r/javascript/" }],
    "searches": ["apify"],
}

# Run the Actor and wait for it to finish
run = client.actor("practicaltools/reddit-claude-connector").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 '{
  "startUrls": [
    {
      "url": "https://www.reddit.com/r/javascript/"
    }
  ],
  "searches": [
    "apify"
  ]
}' |
apify call practicaltools/reddit-claude-connector --silent --output-dataset

```

## MCP server setup

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

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/Ra1m1u40WymGhpJfv/builds/TkvpbT22T3UN1CcH3/openapi.json