# Reddit User Monitor - Archived & Hidden Profile History (`automly/reddit-user-monitor`) Actor

Find archived Reddit user posts and comments, including public activity missing from hidden profiles. Export CSV, Excel or JSON, filter by date, and schedule snapshots. $1 per 1,000 results; no start fee. Coverage depends on available archives.

- **URL**: https://apify.com/automly/reddit-user-monitor.md
- **Developed by:** [Automly](https://apify.com/automly) (community)
- **Categories:** Social media, Automation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 archived activities

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 User Monitor - Archived & Hidden Profile History

**Reddit User Monitor** is a Reddit user history scraper that finds archived posts and comments, including public activity missing from hidden profiles when that activity is available in the archive. Enter usernames or profile links, choose a date range, and export the results to CSV, Excel or JSON.

Use it for a historical lookup or recurring snapshots on an Apify schedule. No Reddit login or Reddit API key is needed.

- **Archived Reddit history:** collect older posts and comments by username.
- **Hidden-profile activity:** find archived public contributions even when the profile does not display them.
- **Bulk user monitoring:** enter up to 100 usernames per run and choose separate post and comment limits.
- **Simple pricing:** $1 per 1,000 saved posts or comments, with no actor start fee or hidden-profile surcharge.

### Can you find history from hidden Reddit profiles?

Yes. Reddit User Monitor searches archived public activity by username, so a hidden profile does not prevent it from returning posts and comments already available in the archive. The same input works for visible profiles and profiles that hide their activity.

This is useful when a profile shows little or no history, or when you need older contributions. Availability depends on what was captured: the actor does not guarantee a complete history or determine whether an account is currently hidden. Private messages, chats and content from private communities are outside its scope.

### What can you do with Reddit User Monitor?

- **Export Reddit user post and comment history** for one account or a list of usernames.
- **Find archived Reddit activity by date**, including contributions no longer listed on a profile.
- **Monitor Reddit users on a schedule** with a rolling lookback such as the last seven days.
- **Review your own account history** or public contributions relevant to a community.
- **Build activity timelines** using original publication dates, community names and stable item IDs.
- **Connect historical exports to your workflow** through the Apify API, Make, n8n or Zapier.

Each run includes a report showing which user histories were retrieved, which reached a limit and which could not be completed.

### How much does Reddit User Monitor cost?

The actor charges **$0.001 for each saved post or comment: $1 per 1,000 results**. Posts and comments have the same price. There is no actor start fee, profile lookup fee or extra charge for hidden-profile history.

| Results saved | Actor fee |
| --- | ---: |
| 100 posts or comments | $0.10 |
| 188 posts or comments | $0.188 |
| 1,000 posts or comments | $1.00 |
| 10,000 posts or comments | $10.00 |

An empty result has no result fee. Partial runs charge for the items actually saved. Overlapping snapshots can save the same item on different runs; each saved occurrence is billable. Set a maximum charge before running to control spending.

These are actor fees. Check the **Pricing** tab for current terms and any applicable platform usage charges; the optional Standby API also incurs Apify platform usage.

### How to export Reddit user history

1. Sign in to [Apify](https://console.apify.com/) and open Reddit User Monitor.
2. Enter usernames, Reddit profile URLs or Redveal profile URLs.
3. Set your post and comment limits, then choose available history, a fixed date range or a rolling lookback.
4. Click **Start** and review the results and **Run report**.
5. Download the dataset as CSV, Excel or JSON, or use it in an integration.

#### Input settings

| Setting | Input field | Default and limits |
| --- | --- | --- |
| Usernames or profile links | `usernames` | Required; 1–100 entries. Repeated usernames and case variants are combined within the run. |
| Maximum posts per user | `maxPosts` | `100`; choose 0–10,000. Set to `0` to skip posts. |
| Maximum comments per user | `maxComments` | `1000`; choose 0–10,000. Set to `0` to skip comments. |
| From (inclusive) | `since` | Optional date or timestamp; blank includes all available earlier history. |
| Until (exclusive) | `until` | Optional date or timestamp; blank uses the start of the run. |
| Rolling lookback (days) | `lookbackDays` | Optional; 1–3,650 days, recalculated on every run. Use instead of fixed dates. |

At least one activity limit must be greater than zero. Dates without a timezone use UTC. For example, `2026-09-01` means midnight at the beginning of September 1.

#### Retrieve available archived history

```json
{
  "usernames": ["reddit"],
  "maxPosts": 100,
  "maxComments": 1000
}
```

The actor accepts `reddit`, `u/reddit`, `https://www.reddit.com/user/reddit/` and `https://redveal.com/user/reddit`. A profile link identifies the username; it does not change archive coverage.

#### Export a fixed date window

This example includes activity created from September 1 through September 6, UTC. The September 7 boundary is excluded.

```json
{
  "usernames": ["reddit"],
  "maxPosts": 100,
  "maxComments": 500,
  "since": "2026-09-01",
  "until": "2026-09-07"
}
```

#### Monitor the last seven days

```json
{
  "usernames": ["reddit"],
  "maxPosts": 100,
  "maxComments": 500,
  "lookbackDays": 7
}
```

Save this input as an Apify task and attach an [Apify schedule](https://docs.apify.com/schedules). Each run recalculates the window and writes a fresh snapshot. Daily runs with a seven-day lookback overlap, which helps catch items added to the archive late.

There is no persistent deduplication between runs. To keep only newly observed activity in your own workflow, compare each item's `id` with IDs you have already stored. The actor does not provide instant alerts, and recently published activity may take time to reach the archive.

### What data is included in the export?

Every dataset row represents one post or comment. Results are newest first within each user's posts or comments; sort by `createdAt` after export for a combined timeline.

| Data | Output fields | Meaning |
| --- | --- | --- |
| Identity | `type`, `id`, `username`, `author` | Activity type, stable Reddit ID, normalized username and archived author spelling |
| Content | `title`, `body`, `url` | Post title, post text or comment body, and a post's destination URL |
| Community | `subreddit` | The community where the activity appeared |
| Publication time | `createdUtc`, `createdAt` | Original timestamp as epoch seconds and a UTC date |
| Capture time | `archivedAt`, `fetchedAt` | Archive capture date when available, and this snapshot's retrieval date |
| Archived engagement | `score`, `numComments` | Score and comment count as captured, which may differ from current values |
| Context | `postId`, `parentId`, `permalink` | Parent post, reply target and link to the activity |
| Source | `source` | Always `archive`: the result comes from archived public activity |

#### Example output

This is an actual archived post by Reddit's official `u/reddit` account. A deleted or removed body keeps Reddit's `[deleted]` or `[removed]` marker; the actor never invents missing text.

```json
{
  "type": "post",
  "id": "t3_175ktxy",
  "username": "reddit",
  "author": "reddit",
  "subreddit": "bbuk",
  "title": "r/bbuk Lounge",
  "body": "A place for members of r/bbuk to chat with each other",
  "score": 1,
  "createdUtc": 1697048017,
  "createdAt": "2023-10-11T18:13:37Z",
  "archivedAt": "2023-10-11T18:13:50Z",
  "fetchedAt": "2026-10-01T19:30:00Z",
  "permalink": "https://www.reddit.com/comments/175ktxy/",
  "url": "https://www.reddit.com/r/bbuk/comments/175ktxy/rbbuk_lounge/",
  "postId": "t3_175ktxy",
  "parentId": null,
  "numComments": 0,
  "source": "archive"
}
```

Unavailable or inapplicable fields are `null`; an empty text field may remain an empty string. Comment IDs start with `t1_` and post IDs with `t3_`, so the IDs can be used together without collisions.

### Can I use a Reddit user history API?

Yes. Use Apify's actor-run API to start a snapshot and retrieve its dataset. The following example returns up to 20 posts and 20 comments:

```bash
curl --request POST \
  'https://api.apify.com/v2/acts/automly~reddit-user-monitor/run-sync-get-dataset-items' \
  --header "Authorization: Bearer ${APIFY_TOKEN}" \
  --header 'Content-Type: application/json' \
  --data '{"usernames":["reddit"],"maxPosts":20,"maxComments":20}'
```

Use asynchronous [actor runs](https://docs.apify.com/api/v2/actors-runs-post) for larger histories. The optional Standby endpoint supports `GET /activity?username=reddit&maxPosts=20&maxComments=20`, plus `since`, `until` or `lookbackDays`. It returns `count`, `items` and `report`, saves the same items to the dataset, and supports up to 100 posts and 100 comments per call. Authenticate through Apify; no Reddit credentials are needed.

### Frequently asked questions

#### Can I retrieve deleted or removed Reddit posts and comments?

Reddit User Monitor can return a deleted or removed item's archived text when that text is still available in the public archive. If the archive contains only `[deleted]` or `[removed]`, that marker is returned. Content that was never captured cannot be recovered by this actor.

#### Can I get more than 1,000 items from a user's history?

Reddit User Monitor allows up to 10,000 archived posts and 10,000 archived comments per user per run. Actual results depend on the archive's available records, the selected date window and your spending limit. A higher limit does not guarantee that more records exist.

#### Is this real-time Reddit monitoring?

Reddit User Monitor provides scheduled snapshots of archived activity. It is suitable for historical research and recurring exports, but archive updates can lag behind Reddit. Use an overlapping lookback for recurring snapshots and compare stable IDs in your destination system.

#### How do I know whether a history export is complete?

Open the **Run report**. `exhausted` or `empty` means no further matches were found for the archive query. `limit_reached` or `cost_limit` means collection stopped at a cap. `partial` or `failed` identifies retrieval problems; already saved rows remain available. An exhausted archive query does not prove complete lifetime coverage, and an empty result does not prove the account does not exist.

#### Does the actor identify which profiles are hidden?

Reddit User Monitor retrieves archived activity without classifying the current profile's visibility. A returned item does not, by itself, prove that the profile is hidden or that the item was deleted. Use the export as a record of available archived activity.

#### Is this connected to Redveal or Reddit?

Reddit User Monitor is an independent Automly tool, not affiliated with, endorsed by or sponsored by Reddit or Redveal. It accepts Redveal links as a convenient way to enter a username.

#### What if a run cannot retrieve my results?

Check the Run report for the affected username and activity type. Archive availability and freshness can vary. If the issue persists, report it through the actor's **Issues** tab with your run ID and input settings, excluding credentials.

### More Reddit scraping tools

| Tool | Use it for |
| --- | --- |
| [Reddit Scraper](https://apify.com/automly/reddit-scraper) | Current subreddit posts and post searches |
| [Reddit Comment Scraper](https://apify.com/automly/reddit-comment-scraper) | Comments from Reddit post links |
| [Reddit Ultimate Scraper](https://apify.com/automly/reddit-ultimate-scraper) | Multiple current Reddit content types in one workflow |

*Last verified September 27, 2026: one sample account returned 16 posts and 172 comments. A separate date-window check returned exactly the three expected items. These are observed examples, not guarantees for other accounts.*

# Actor input Schema

## `usernames` (type: `array`):

Enter Reddit usernames, Reddit profile URLs or Redveal profile URLs. Only available public archive activity is returned.

## `maxPosts` (type: `integer`):

Set a per-user limit. Use 0 to skip this activity type.

## `maxComments` (type: `integer`):

Set a per-user limit. Use 0 to skip this activity type.

## `since` (type: `string`):

Enter a UTC date or ISO timestamp, for example 2026-09-01. Leave blank for all available history.

## `until` (type: `string`):

Enter a UTC date or ISO timestamp. Leave blank to use the start of the run.

## `lookbackDays` (type: `integer`):

Retrieve the last N days, recalculated on each run. Use for schedules. Cannot be combined with From or Until.

## Actor input object example

```json
{
  "usernames": [
    "reddit"
  ],
  "maxPosts": 100,
  "maxComments": 1000
}
```

# Actor output Schema

## `activity` (type: `string`):

No description

## `report` (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 = {
    "usernames": [
        "reddit"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automly/reddit-user-monitor").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 = { "usernames": ["reddit"] }

# Run the Actor and wait for it to finish
run = client.actor("automly/reddit-user-monitor").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 '{
  "usernames": [
    "reddit"
  ]
}' |
apify call automly/reddit-user-monitor --silent --output-dataset

```

## MCP server setup

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

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/6KcdcxDjhrd5YW2qD/builds/MF0dTQQP0Ulh2Cug5/openapi.json