# Reddit Post View Booster API (`webm/reddit-post-view-booster-api`) Actor

Boost views on any Reddit post — on demand. Deliver from a few to thousands of real view events through your own proxies, instantly or spread naturally over time. Pay only for views that land. Simple API, fully automatable

- **URL**: https://apify.com/webm/reddit-post-view-booster-api.md
- **Developed by:** [George WebM](https://apify.com/webm) (community)
- **Categories:** Social media, Automation, Lead generation
- **Stats:** 5 total users, 1 monthly users, 92.0% runs succeeded, 5 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 1,000 boosted view (low quality)s

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 Post View Booster — Increase Reddit Views

**Get more views on any Reddit post or comment — on demand.** Give it a post or
comment link and your own proxies, send anywhere from a handful to tens of
thousands of views, and choose whether they land all at once or build up
naturally over time. Call it as a simple API and automate it into your own
workflow.

> ⚠️ **Unofficial.** Not affiliated with Reddit.
> All trademarks belong to their respective owners.

### Why use this

- **Pay only for views that land.** Billing is per **successfully delivered**
  view — failed attempts are free. No wasted spend.
- **Use your own proxies.** Reddit blocks many IPs, so bring
  **good** proxies whose IPs Reddit hasn't flagged — e.g. a quality
  shared-datacenter provider like **DataImpulse**. (Apify's own proxies —
  datacenter and residential — are blocked by Reddit.) Credentials are never stored.
- **Natural-looking growth.** Send an instant spike, or spread views over
  minutes/hours so a post looks like it's catching attention on its own.
- **Built for volume.** Send large batches unattended — up to **100,000 views**
  per run, delivered instantly or spread over time (up to 24h). Tip: keep the
  spread window short — you pay for server time while the run is alive, so a
  multi-hour window costs you more.
- **Fully automatable.** Trigger it from the **Apify API**, **webhooks**,
  **schedules**, or **Make / Zapier / n8n** — not just the dashboard.

### Quick start

1. **Copy the post URL** — e.g. `https://www.reddit.com/r/<sub>/comments/<id>/…`
   (or a comment permalink `…/comments/<id>/comment/<commentId>/` to boost a comment).
2. **Add your proxies** (required) — good ones, a quality shared-datacenter provider like DataImpulse.
   (Apify's own proxies don't work — Reddit blocks them.)
3. **Run it** — set how many views (`count`) and press start. Results appear in
   the run's dataset.

```json
{
  "postUrl": "https://www.reddit.com/r/<sub>/comments/<id>/<slug>/",
  "count": 1000,
  "proxyUrls": ["http://user:pass@host:port"]
}
```

### Use cases

- **Give a new post initial traction** — add view volume to a fresh post so it
  doesn't sit at zero while it's most likely to catch organic attention.
- **Boost a comment too** — pass a comment link to add views on that comment's
  thread, e.g. to lift a key reply in a busy discussion.
- **Marketing & growth campaigns** — increase the view count on a promotional or
  announcement post to strengthen social proof.
- **Creators & community managers** — boost views on your subreddit's or brand's
  posts as part of a wider engagement push.
- **Scheduled & automated boosts** — trigger views on demand from your own
  scheduler, bot, or workflow via the API.

### Quality: low vs high

- **`low`** — anonymous views. Fast and cheap.
- **`high`** — **maximum realism**: views crafted to look like genuine visits, for
  the highest-quality result.

Pick with the `quality` field. Everything else (proxies, modes, timing) is the
same.

### Pricing — pay for results

You only pay per **successfully delivered** view. Failed views cost nothing.

| Quality | Price |
|---|---|
| **`low`** — anonymous | **$1 per 1,000 views** |
| **`high`** — maximum realism | **$2.5 per 1,000 views** |

**Free plan:** 20 runs to try it out (up to 100 views each, low or high). Paid
plans are unlimited.

### FAQ

**How do I increase views on a Reddit post?**
Copy the post link, add your proxies, set how many views you want, and run.
Choose an instant burst or spread the views over time.

**Are the views real?**
Yes — the tool sends the same view signals Reddit records when a real person
opens a post. Delivered views show up in the author's **Post Insights**.

**Can I boost views on a comment?**
Yes — paste a comment permalink (`…/comments/<id>/comment/<commentId>/`) instead
of a post URL. The tool detects it automatically and boosts views on that
comment's thread.

**Do I need proxies?**
**Yes — required.**

**Can I automate or schedule it?**
Yes — run it from the **Apify API**, a **webhook**, a **schedule**, or
**Make / Zapier / n8n**.

***

### Reference

Everything below is optional — the defaults just work.

#### Input parameters

| Field | Required | Default | Description |
|---|---|---|---|
| `postUrl` | yes | — | Full Reddit **post** URL (`…/comments/<id>/…`) or a **comment** permalink (`…/comments/<id>/comment/<commentId>/`). Auto-detected. |
| `count` | no | 5000 | How many views to send (max 100,000; free plan 100). |
| `quality` | no | `low` | `low` = anonymous views. `high` = maximum realism. See **Quality** below. |
| `mode` | no | `fast` | Delivery style — see **Modes** below. |
| `spreadSeconds` | for `random`/`wave` | — | Time window (seconds, max 86,400 = 24h) to spread views over. Required for `random`/`wave`; ignored for `fast`. |
| `proxyUrls` | **yes** | — | Your own good proxies (Reddit blocks datacenter/shared IPs) — a quality shared-datacenter provider like DataImpulse. Apify's own proxies (datacenter/residential) are blocked. Format `http://user:pass@host:port`. |

#### Modes

- **`fast`** — deliver everything as an immediate spike. No timing needed.
- **`random`** — spread views **evenly** over `spreadSeconds` for a steady stream.
- **`wave`** — views **rise quickly, then tail off**, so a post looks like it's
  catching attention and cooling down. Needs `spreadSeconds`.

If a time window is too short to fit the requested `count`, the run returns the
minimum feasible number of seconds so you can adjust.

#### Post types

Reddit treats a post slightly differently depending on where it lives; the tool
handles all of these automatically:

- **Subreddit post** — `https://www.reddit.com/r/<sub>/comments/<id>/…`
- **Profile post** — `https://www.reddit.com/user/<name>/comments/<id>/…`
- **Comment** — `https://www.reddit.com/r/<sub>/comments/<id>/comment/<commentId>/`
  (or the `/user/<name>/…` form). Boosts views on that comment's thread.

Short share links (`/r/<sub>/s/<code>`) aren't supported — use the full `…/comments/<id>/…` link.

#### Run via the Apify API

Starting a run returns a run ID immediately; the boost then runs in the
background for as long as it needs.

```bash
curl -X POST 'https://api.apify.com/v2/acts/<username>~reddit-boost-views/runs?token=<APIFY_TOKEN>' \
  -H 'content-type: application/json' \
  -d '{ "postUrl": "https://www.reddit.com/r/<sub>/comments/<id>/<slug>/", "count": 1000, "proxyUrls": ["http://user:pass@host:port"] }'
```

Read results from the run's dataset (or the `OUTPUT` record), or attach a webhook
for a completion callback.

#### Output

Each run writes one summary item to the dataset:

```json
{
  "success": true,
  "postUrl": "https://www.reddit.com/r/…/comments/abc123/…/",
  "target": "post",
  "requestedViews": 1000,
  "successfulRequests": 987,
  "failedRequests": 13,
  "duration": "22.4s"
}
```

### Notes

- Reddit view counts are private to the author (Post Insights), so the tool reports the views it **delivered**, not a
  before/after number.

***

This is an unofficial tool and is not affiliated with, endorsed by, or sponsored
by Reddit. All trademarks are the property of their respective owners.

# Actor input Schema

## `action` (type: `string`):

Which operation to run. Only 'boost-views' is available for now.

## `postUrl` (type: `string`):

Full Reddit post URL (…/comments/<id>/…) to boost post views, or a comment permalink (…/comments/<id>/comment/<commentId>/…) to boost views on that comment thread. Post type (subreddit vs profile) and post vs comment are auto-detected.

## `quality` (type: `string`):

Anonymous views, or maximum realism (higher quality, higher price).

## `count` (type: `integer`):

How many views to send. Free plan is capped to 100; paid up to 100000.

## `mode` (type: `string`):

How views are delivered. 'fast' = immediate burst (up to 5000 views in flight), no time needed. 'random' = spread uniformly over a time window (requires 'spreadSeconds'). 'wave' = fast rise then gentle decline over a time window (requires 'spreadSeconds').

## `spreadSeconds` (type: `integer`):

Time window to spread the views over (max 86400 = 24h). Required for 'random' and 'wave'; ignored for 'fast'. Rejected if below the minimum feasible window for the given view count.

## `maxTries` (type: `integer`):

Retries per view on a transport error / 5xx / 429 — each retry moves to the next proxy.

## `postType` (type: `string`):

Event shape. 'auto' detects it from the URL (…/user/<name>/comments/… → profile, …/r/<sub>/comments/… → subreddit). Force with 'profile' or 'subreddit'.

## `proxyUrls` (type: `array`):

Your own proxy URLs (required). Reddit blocks datacenter/shared server IPs, so you need GOOD proxies whose IPs Reddit hasn't flagged — e.g. a quality shared-datacenter provider like DataImpulse. Apify's own proxies (datacenter and residential) are blocked by Reddit. The actor rotates through them and retries a failed view on the next. Format: http://user:pass@host:port

## `csrf` (type: `string`):

Optional CSRF token captured from a real Reddit event request.

## `userAgent` (type: `string`):

Force a single User-Agent for every view. Leave empty to auto-generate a realistic browser fingerprint (User-Agent + client hints) per view.

## `postId` (type: `string`):

Override the t3\_<id> normally derived from postUrl.

## `post` (type: `object`):

Override fields of the event's post object (merged over the captured defaults).

## `subreddit` (type: `object`):

For subreddit posts only. Override the event's subreddit block, e.g. { "id": "t5\_...", "name": "..." }. The name is derived from the URL by default.

## `microappRoute` (type: `string`):

Override the x-sh-microapp-route header. Leave empty to use the value for the detected post type (profile → 'profiles', subreddit → 'pdp').

## `pageType` (type: `string`):

Override action\_info.page\_type. Leave empty for 'post\_detail'.

## `routeName` (type: `string`):

Override action\_info.route\_name. Leave empty to use the value for the detected post type (profile → 'profile\_post\_page', subreddit → 'post\_page').

## Actor input object example

```json
{
  "action": "boost-views",
  "postUrl": "https://www.reddit.com/r/test/comments/abc123/some_slug/",
  "quality": "low",
  "count": 5000,
  "mode": "fast",
  "maxTries": 3,
  "postType": "auto",
  "proxyUrls": [
    "http://user:pass@host:port"
  ]
}
```

# Actor output Schema

## `results` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("webm/reddit-post-view-booster-api").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("webm/reddit-post-view-booster-api").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 '{}' |
apify call webm/reddit-post-view-booster-api --silent --output-dataset

```

## MCP server setup

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

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/v6bDqpqlifrjLgoy1/builds/SPoBMvUnff8AovIKq/openapi.json