# Reddit Archive Scraper - Posts & Comments ($0.75/1K) (`whoareyouanas/reddit-faster-actor`) Actor

Export archived Reddit posts and comments by subreddit or user with UTC date filters. No Reddit API key, login, cookies, or proxy setup. Built on Arctic Shift for fast historical backfills, AI/RAG datasets, monitoring, and SEO research at $0.75 per 1,000 rows.

- **URL**: https://apify.com/whoareyouanas/reddit-faster-actor.md
- **Developed by:** [Anas Nadeem](https://apify.com/whoareyouanas) (community)
- **Categories:** Social media, News, AI
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.75 / 1,000 reddit results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Archive Scraper - Posts & Comments ($0.75/1K)

Export archived Reddit posts and comments from public subreddits or user profiles without a Reddit API key, OAuth app, cookies, login, or proxy setup.

This Actor is built for historical Reddit backfills: research datasets, AI/RAG ingestion, SEO topic mining, brand monitoring inside known communities, user history exports, and scheduled incremental jobs. It uses the Arctic Shift Photon Reddit API, paginates by UTC timestamps, splits large date windows automatically, retries transient failures, and removes duplicates within each run.

### Why use it

- **Archive depth beyond Reddit listing limits**: collect historical posts and comments instead of stopping at the usual recent listing window.
- **Cheaper than broad Reddit scrapers**: `$0.75 per 1,000` posts or comments, with no proxy charge by default.
- **No Reddit setup**: no Reddit API key, no OAuth application, no cookies, no login.
- **Fast HTTP collection**: no browser runtime; requests go directly to the archive backend.
- **Date-bounded exports**: use UTC `startDate` and `endDate` for precise research windows or incremental monitoring.
- **Posts and comments together**: select `posts`, `comments`, or both in one run.
- **Clean preview plus raw source data**: simple fields for CSV/JSON/Excel plus the original archive row in `rawData`.
- **Resumable jobs**: checkpoints are saved to the key-value store for long or recurring backfills.

### Best for

- Historical subreddit exports, such as every `r/wallstreetbets` post during a market event.
- Public Reddit user history exports for posts and comments.
- AI/RAG datasets where you need dated Reddit discussion text.
- SEO research from old questions, selftext, and discussion URLs.
- Brand or competitor monitoring inside known communities.
- Recurring jobs that pull only new rows since the last checkpoint.

### Pricing

**$0.75 per 1,000 Reddit posts or comments** with Apify pay-per-event pricing.

One result is one post or one comment written to the default dataset. Failed requests, skipped empty windows, duplicate records, metadata calls, and dry runs do not produce billable result rows.

| Volume | Actor charge |
| ---: | ---: |
| 1,000 rows | `$0.75` |
| 10,000 rows | `$7.50` |
| 100,000 rows | `$75.00` |
| 1,000,000 rows | `$750.00` |

No Reddit API key, no login, and no proxy charge by default. Apify platform charges may still apply depending on your plan.

### Comparison

| Capability | This Actor | Broad live Reddit scrapers | PRAW / official API | Pushshift-style archives |
| --- | --- | --- | --- | --- |
| Historical subreddit backfills | Strong | Limited by live listing depth | Usually limited | Varies |
| Public user post/comment history | Yes | Usually yes | Limited and API-gated | Varies |
| UTC date windows | Purpose-built | Basic or inconsistent | Requires custom code | Usually yes |
| No Reddit API key | Yes | Usually yes | No | Usually yes |
| No login/cookies | Yes | Usually yes | No OAuth required after setup, but app setup required | Usually yes |
| No proxy by default | Yes | Often no | Yes | Yes |
| Direct Reddit post URLs | No | Yes | Yes | Usually no |
| Global keyword search | No | Yes | Yes, with limits | Varies |
| Community/user metadata | Metadata saved separately | Usually first-class | Yes | Varies |
| Raw source payload | Yes, `rawData` | Usually no | Yes, if coded | Usually yes |
| Starting price | `$0.75 / 1K rows` | Often `$1.20-$3.40+ / 1K rows` | Free but engineering-heavy | Varies |

Use a broad live scraper when you need arbitrary Reddit URLs, live search pages, subreddit metadata rows, or a single live post thread. Use this Actor when you need cheap, repeatable, date-bounded archive exports for known subreddits or users.

### Input

Minimum input:

```json
{
  "targets": ["r/Python"]
}
```

Quick test run:

```json
{
  "targets": ["r/Python"],
  "datasets": ["posts"],
  "startDate": "2024-01-01",
  "endDate": "2024-01-01",
  "maxItemsPerKind": 1,
  "limit": "5"
}
```

Common backfill run:

```json
{
  "targets": ["r/solotravel", "u/spez"],
  "datasets": ["posts", "comments"],
  "startDate": "2024-01-01",
  "endDate": "now",
  "maxItemsPerKind": 1000
}
```

Daily incremental monitoring:

```json
{
  "targets": ["r/SaaS", "r/startups"],
  "datasets": ["posts", "comments"],
  "startDate": "2026-08-01",
  "endDate": "now",
  "resumeFromState": true,
  "maxItemsPerKind": 5000
}
```

`startDate` and `endDate` are interpreted as UTC. A `YYYY-MM-DD` end date is exclusive of the next UTC day, so `"endDate": "2024-01-01"` means before `2024-01-02T00:00:00Z`.

### Input fields

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `targets` | `string[]` | Required | Reddit targets in `r/name` or `u/name` form. |
| `datasets` | `string[]` | `["posts"]` in schema prefill | Choose `posts`, `comments`, or both. |
| `startDate` | `string` | `2024-01-01` | UTC lower bound. Supports `YYYY-MM-DD`, ISO datetime, epoch seconds, epoch milliseconds, `none`, or `all`. |
| `endDate` | `string` | `2024-01-01` | UTC upper bound. Use `now` for current time. |
| `maxItemsPerKind` | `integer` | `1` | Optional cap for newly pushed rows per selected dataset and target. |
| `maxPagesPerKind` | `integer` | Empty | Optional cap for fetched non-empty API pages per selected dataset and target. |
| `limit` | `string` | `5` | Arctic Shift API limit parameter. Increase for large exports. |
| `windowDays` | `number` | `1` | Maximum time span per API request. Use `0` to disable windowing. |
| `requestDelayMs` | `integer` | `0` | Delay between successful non-empty page requests. |
| `timeoutSeconds` | `number` | `60` | HTTP timeout for each archive request. |
| `retries` | `integer` | `3` | Retries for transient HTTP or network failures. |
| `skipMetadata` | `boolean` | `false` | Skip subreddit/user metadata lookup. |
| `dryRun` | `boolean` | `false` | Build request URLs and summaries without fetching rows or charging result events. |
| `resumeFromState` | `boolean` | `true` | Continue from saved checkpoint records when present. |
| `baseUrl` | `string` | Arctic Shift API | Advanced override for the archive API base URL. |

### Output

Rows are pushed to the default dataset with a small Actor envelope and the original Arctic Shift row in `rawData`.

```json
{
  "createdAt": "2023-11-14T22:13:20Z",
  "author": "AutoModerator",
  "title": "Monday Daily Thread: Project ideas!",
  "link_flair_text": "Daily Thread",
  "description": "Post selftext for posts, or comment body for comments.",
  "url": "https://www.reddit.com/r/solotravel/comments/example/title/",
  "kind": "post",
  "redditId": "example",
  "rawData": {}
}
```

The default Output tab shows `createdAt`, `author`, `title`, `link_flair_text`, `description`, and `url` first. Use the Debug view or JSON export when you need the raw archive payload.

The key-value store receives:

- `OUTPUT`: final run summary
- `METADATA-{target}`: raw metadata response when metadata is enabled
- `STATE-{target}-{posts|comments}`: latest checkpoint for resumable runs

### API examples

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/whoareyouanas~reddit-faster-actor/run-sync-get-dataset-items" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "targets": ["r/Python"],
    "datasets": ["posts", "comments"],
    "startDate": "2024-01-01",
    "endDate": "2024-02-01",
    "maxItemsPerKind": 1000
  }'
```

#### Python SDK

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("whoareyouanas/reddit-faster-actor").call(run_input={
    "targets": ["r/Python"],
    "datasets": ["posts", "comments"],
    "startDate": "2024-01-01",
    "endDate": "2024-02-01",
    "maxItemsPerKind": 1000,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

#### Node.js SDK

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('whoareyouanas/reddit-faster-actor').call({
    targets: ['r/Python'],
    datasets: ['posts', 'comments'],
    startDate: '2024-01-01',
    endDate: '2024-02-01',
    maxItemsPerKind: 1000,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### n8n, Make, Zapier, and schedules

Use the Apify integration in n8n, Make, or Zapier and point it to actor `whoareyouanas/reddit-faster-actor`. For recurring monitoring, schedule a daily run with `endDate: "now"` and `resumeFromState: true`, then send new rows to Google Sheets, Airtable, Slack, S3, BigQuery, or an AI summarization step.

### Data source and accuracy

Records are emitted from the Arctic Shift archive response with minimal reshaping. The Actor preserves the full source payload in `rawData`, so users can audit the original fields.

This is an archive-backed scraper, not an official Reddit API client. Very recent content and engagement metrics can lag behind live Reddit, and deleted, removed, private, banned, or unavailable content may be absent or redacted by the upstream source. The strongest truthful claim is high-fidelity archive export, not a blanket 100% accuracy guarantee.

### FAQ

#### Does this require a Reddit API key?

No. The Actor uses Arctic Shift and does not require Reddit OAuth, app registration, cookies, or a logged-in Reddit account.

#### Can it scrape old Reddit posts?

Yes. This Actor is designed for historical exports with UTC date ranges and timestamp-based pagination.

#### Can it scrape comments?

Yes. Select `comments` in `datasets` to export comment rows. Select both `posts` and `comments` to collect both kinds in one run.

#### Can it scrape a full Reddit URL?

Not yet. Use `r/name` or `u/name` targets. Use a broad live Reddit scraper when you need arbitrary post URLs, live search pages, or direct thread scraping.

#### Can it scrape private subreddits?

No. It only exports data available through the public archive source.

#### Why did my run return fewer rows than expected?

The archive may not contain every deleted, removed, private, banned, or very recent item. Date windows, `maxItemsPerKind`, `maxPagesPerKind`, and upstream availability also affect row counts.

#### Is it affiliated with Reddit?

No. This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by Reddit.

### Responsible use

This Actor extracts publicly available archived Reddit data. You are responsible for using the data in compliance with Reddit's terms, Arctic Shift availability and policies, and applicable privacy and data-protection laws.

### Search keywords

reddit scraper, reddit api, reddit archive scraper, reddit historical scraper, reddit posts scraper, reddit comments scraper, subreddit scraper, reddit user history, Pushshift alternative, Arctic Shift

### Local checks

```bash
python -m unittest discover -v
python -m json.tool .actor/input_schema.json >/tmp/reddit-faster-input-schema.json
```

# Actor input Schema

## `targets` (type: `array`):

Reddit targets in r/name or u/name form.

## `datasets` (type: `array`):

Select which Reddit object types to download.

## `startDate` (type: `string`):

UTC lower bound. Supports YYYY-MM-DD, ISO datetime, epoch seconds, epoch milliseconds, none, or all.

## `endDate` (type: `string`):

UTC upper bound. YYYY-MM-DD is exclusive of the next UTC day. Use now for the current time.

## `maxItemsPerKind` (type: `integer`):

Optional cap for newly pushed rows per selected dataset and target.

## `maxPagesPerKind` (type: `integer`):

Optional cap for fetched non-empty API pages per selected dataset and target.

## `limit` (type: `string`):

Arctic Shift limit parameter. Increase for large exports; the prefilled value keeps example runs small.

## `windowDays` (type: `number`):

Maximum time span per API search request. Use 0 to disable windowing.

## `minWindowSeconds` (type: `integer`):

Smallest retry window after oversized API range responses.

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

Delay between successful non-empty page requests.

## `timeoutSeconds` (type: `number`):

HTTP timeout for each Arctic Shift request.

## `retries` (type: `integer`):

Retries for transient HTTP or network failures.

## `retrySleepSeconds` (type: `number`):

Base sleep between retries. Later retries wait a multiple of this value.

## `skipMetadata` (type: `boolean`):

Skip the subreddit/user metadata request. Provide startDate for large ranges when enabled.

## `dryRun` (type: `boolean`):

Build request URLs and summary records without fetching posts/comments or pushing dataset rows.

## `resumeFromState` (type: `boolean`):

Continue from checkpoint records in the default key-value store when present.

## `verboseLog` (type: `boolean`):

Log each progress update instead of every page checkpoint interval.

## `baseUrl` (type: `string`):

Advanced override for the Arctic Shift Photon Reddit API base URL.

## Actor input object example

```json
{
  "targets": [
    "r/Python"
  ],
  "datasets": [
    "posts"
  ],
  "startDate": "2024-01-01",
  "endDate": "2024-01-01",
  "maxItemsPerKind": 1,
  "limit": "5",
  "windowDays": 1,
  "minWindowSeconds": 60,
  "requestDelayMs": 0,
  "timeoutSeconds": 60,
  "retries": 3,
  "retrySleepSeconds": 2,
  "skipMetadata": false,
  "dryRun": false,
  "resumeFromState": true,
  "verboseLog": false,
  "baseUrl": "https://arctic-shift.photon-reddit.com/api"
}
```

# Actor output Schema

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

No description

## `summary` (type: `string`):

No description

# 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 = {
    "targets": [
        "r/Python"
    ],
    "datasets": [
        "posts"
    ],
    "startDate": "2024-01-01",
    "endDate": "2024-01-01",
    "maxItemsPerKind": 1,
    "limit": "5",
    "windowDays": 1,
    "requestDelayMs": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("whoareyouanas/reddit-faster-actor").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 = {
    "targets": ["r/Python"],
    "datasets": ["posts"],
    "startDate": "2024-01-01",
    "endDate": "2024-01-01",
    "maxItemsPerKind": 1,
    "limit": "5",
    "windowDays": 1,
    "requestDelayMs": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("whoareyouanas/reddit-faster-actor").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 '{
  "targets": [
    "r/Python"
  ],
  "datasets": [
    "posts"
  ],
  "startDate": "2024-01-01",
  "endDate": "2024-01-01",
  "maxItemsPerKind": 1,
  "limit": "5",
  "windowDays": 1,
  "requestDelayMs": 0
}' |
apify call whoareyouanas/reddit-faster-actor --silent --output-dataset

```

## MCP server setup

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

```

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/IWfJCbtH3LYBFhhrb/builds/51Fe1DVsJBuqCZrVW/openapi.json