# Reddit Search Scraper: New Posts Alerts by Keyword & Subreddit (`accountable_eel/reddit-search-lookup`) Actor

Reddit search scraper: reddit posts for a list of keywords or subreddits, one row per post with title, subreddit, score, comments, date, link and text excerpt. New reddit posts alerts for reddit mentions of a brand, or a subreddit monitor to Slack. Without login. Pay per post.

- **URL**: https://apify.com/accountable\_eel/reddit-search-lookup.md
- **Developed by:** [Adrian Voss](https://apify.com/accountable_eel) (community)
- **Categories:** Social media, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.28 / 1,000 post returneds

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 Search Scraper: New Posts Alerts by Keyword & Subreddit

**Watch Reddit for a keyword or a subreddit, get only what's new.** Give it reddit posts for a list of
keywords, a list of subreddits, or both, and schedule it. Each run returns only the posts that
appeared since the last one, charged per new post and free on quiet days. Send them to Slack,
Discord, Google Sheets or n8n.

This actor reads Reddit's public post listings the way a logged-out visitor sees them: a site-wide
search for each keyword, and the post feed of each subreddit, newest first (or hot, or top of the
day, week or month). You get one clean row per post: title, subreddit, author handle, score,
upvote ratio, comment count, posted time, the Reddit link, the link target, flair and the first 300
characters of the text. Turn on monitoring and it becomes new reddit posts alerts for brand
mentions, product launches or a subreddit monitor to Slack, without login and without a Reddit API
key.

### Who it's for

- **Brand and community managers** who want reddit mentions of a brand the hour they happen: a
  watchlist on your product name and your competitors', posted to a Slack channel.
- **Founders and indie hackers** doing market research: every new post asking for "an alternative
  to" your category, or every new thread in r/SaaS, r/Entrepreneur or your niche subreddit.
- **Resellers and deal hunters** who follow r/Flipping, r/buildapcsales or a hobby subreddit and
  don't want to refresh it all day.
- **Researchers and analysts** who need a tidy post dataset for a list of keywords or subreddits,
  without writing and maintaining a Reddit client.

### Why this one

- **Keywords and subreddits in one run.** Site-wide search lines and subreddit feeds side by side,
  each with its own cap (up to 500 posts per line), so one busy keyword can't crowd out the others.
- **Monitoring built in, not bolted on.** `deltaMode` remembers what each keyword and each
  subreddit has already returned. Only new posts come back; everything else is removed before
  billing. A quiet run returns one summary row per line and costs only the start fee.
- **Filters that read the post, not the row.** "Only keep posts mentioning" and "Skip posts
  mentioning" check the title and text only, never the subreddit or author name, and run before
  you are billed. Add a minimum score, and NSFW posts are skipped by default.
- **Lean rows.** A 300-character text excerpt instead of whole bodies, the public author handle
  and nothing else about the person. No comments, no profiles, no avatars.
- **No setup.** No Reddit account, no API key, no proxy settings.

### Monitoring: new reddit posts alerts

1. Put your brand, product or topic in **Search keywords** (one per line) and/or the communities
   to watch in **Subreddits**. Leave **Sort order** on *Newest first*.
2. Tick **Only return posts that are new since the last run**. Optional: **Seed silently** so the
   first run remembers the current posts without sending them anywhere.
3. Save it as a Task and add a Schedule: every hour for brand mentions, once a day for a digest.
4. Each run returns only posts the watchlist has not returned before, each with `isNew: true` and
   `firstSeenAt`. When nothing is new you get one row per line with `postCount: 0` and
   `monitorStatus: NO_NEW_POSTS`, and pay only the start fee.

Memory is kept per keyword and per subreddit, so adding a line to a scheduled list never re-sends
the others. A post nobody has seen for 60 days is forgotten. If more new posts arrive between two
runs than your maximum, the newest are delivered and the rest arrive on the next run, never lost
and never billed twice.

**Weekly top posts digest.** Use *Top* with the time window *Past week*, monitoring on and a weekly
schedule: each Monday you get the week's best posts in each subreddit that you haven't seen yet.

### Price

- **Post returned**: $3 per 1,000 posts

Plus a $0.00005 start fee per run. Each event above is billed independently, only when it actually returns data — misses (`found:false`) are never charged.

- **Posts:** $3 per 1,000 posts returned, plus a $0.00005 start fee per run.
- A monitoring run with nothing new costs the start fee only. A keyword or subreddit that returns
  nothing, a misspelled or private subreddit, and posts removed by your filters are never billed.

A daily digest of 3 keywords that finds 20 new posts a day is about 600 posts a month, **under $2 a
month**. An hourly brand watchlist averaging 3 new posts an hour is about 2,200 posts, **about $6.50
a month**.

### How to use

1. **In the Apify Console.** Open the actor page and click **Start** — the `queries` field is already pre-filled with a working example. Results land in the run's dataset as soon as each item is found.
2. **Via the API.** Call it directly with a POST request — no Console needed once you have an API token:
   ```bash
   curl "https://api.apify.com/v2/acts/accountable_eel~reddit-search-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
     -X POST \
     -H "Content-Type: application/json" \
     -d '{"queries":["apify"]}'
   ```
3. **On a schedule.** Save this actor as an Apify **Task** with the input you want, then add a **Schedule** (hourly, daily, weekly) so it runs on its own — no server of your own required.

Tips:

- Both lists are optional, but at least one needs a line. A subreddit can be written `Flipping`,
  `r/Flipping` or pasted as a link.
- Put a phrase in quotes (`"notion alternative"`) for Reddit's exact-phrase search.
- *Relevance* works for keywords only; a subreddit set to *Relevance* uses *Top* over your time
  window instead.

### Input

```json
{
  "queries": [
    "apify"
  ]
}
```

One Reddit search per line, run across all of Reddit: a brand, a product, a topic or a phrase in quotes. Leave empty to watch only the subreddits below. No login required. Accepted formats: vinted, "apify actor", notion alternative.

A fuller example, a brand watchlist plus two subreddits, new posts only:

```json
{
  "queries": ["vinted", "\"vinted scam\""],
  "subreddits": ["Flipping", "r/vinted"],
  "maxResults": 100,
  "excludeKeywords": ["giveaway"],
  "deltaMode": true
}
```

### Output

One row per post, grouped under the keyword or subreddit that found it (`sourceType`, `source`):

| Field | What it is |
|---|---|
| `id`, `title`, `subreddit` | Reddit's post id, the title, and the subreddit it was posted in |
| `author` | The poster's public Reddit handle, nothing else about them (`null` if deleted) |
| `score`, `upvoteRatio`, `numComments` | Votes, share of upvotes (0 to 1), comment count at the time of the run |
| `createdAt` | When it was posted (ISO 8601, UTC) |
| `permalinkUrl`, `url` | The Reddit discussion link, and the link target (same as the discussion for a text post) |
| `isSelf`, `selftextExcerpt` | Text post or link post; first 300 characters of the text |
| `linkFlairText`, `isNsfw` | The post's flair; whether Reddit marks it 18+ |
| `isNew`, `firstSeenAt` | With monitoring or a named watchlist: new since the last run, and when it was first returned |
| `postCount`, `monitorStatus`, `truncated` | Per keyword or subreddit: posts returned, `NEW_POSTS` / `NO_NEW_POSTS` / `SEEDED`, and whether Reddit stopped the run early |

| query | found | status | sourceType | source | postCount | monitorStatus | truncated | posts | id | title | subreddit | author | score | upvoteRatio | numComments | createdAt | permalinkUrl | url | isSelf | selftextExcerpt | linkFlairText | isNsfw | isNew | firstSeenAt | scrapedAt |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| apify | true | OK | <search or subreddit> | <keyword or subreddit watched> | <posts returned> | <monitoring status> | <stopped early> | \<all posts (full list)> | <post id> | <title> | <subreddit> | \<author (public handle)> | \<score (upvotes)> | <upvote ratio> | <comments> | <posted> | <reddit link> | <link target> | \<text post?> | \<text excerpt (first 300 characters)> | <flair> | \<nsfw?> | \<is this post new?> | <first seen on a run> | 1970-01-01T00:00:00.000Z |

A keyword or subreddit with no posts comes back as a row with `"found": false` and is never charged.

### Use it from Clay, n8n, Make, or an AI agent

This actor runs synchronously over plain HTTP — call it directly from a script, a workflow tool, or an AI agent, no Apify Console needed once you have an API token.

```bash
curl "https://api.apify.com/v2/acts/accountable_eel~reddit-search-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"queries":["apify"]}'
```

**n8n.** Add an HTTP Request node: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~reddit-search-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body Content Type `JSON`, JSON Body `{"queries":["apify"]}` (swap in an expression from an earlier node for a real value).

**Clay.** Add an "HTTP API" column: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~reddit-search-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body `{"queries":["{{search or subreddit}}"]}`, mapping the row's search or subreddit into the `queries` array.

**MCP.** In Claude, Cursor, or any MCP client with the Apify MCP server, ask for "Reddit Search Scraper: New Post Alerts by Keyword" — the agent will find and run this actor.

**Subreddit monitor to Slack without code.** Schedule the monitoring Task, then in n8n or Make
trigger on "Apify: run succeeded", read the run's dataset, skip rows where `postCount` is 0, and
post `title`, `subreddit`, `score` and `permalinkUrl` to a Slack or Discord webhook. For a Google
Sheets log, append the same rows to a sheet instead.

### vs. alternatives

| | What it costs | What you get | Trade-off |
|---|---|---|---|
| **This actor** | $3 per 1,000 posts, quiet monitoring runs free | Keyword search and subreddit feeds in one run, only-new-posts monitoring with per-line memory, title and text filters before billing | Posts only: no comments, no user profiles |
| Popular Reddit scrapers on the Apify Store | $1.15 to $4 per 1,000 results, some with a start fee up to $0.02 | Posts and comments, often user pages too | You rebuild "what's new since yesterday" yourself, and pay again for the posts you already have |
| Social listening tools | Monthly subscription | Dashboards and sentiment | Their keywords and their limits; exporting the raw posts is usually a paid extra |
| Reddit's own API | Free tier, then paid | Everything, with an app and OAuth | Needs a registered app, token handling and rate-limit code; commercial use needs Reddit's approval |

Store figures as of September 2026.

### Data & privacy

**Data & privacy.** This actor reads public post listings that anyone can see without logging in. It
doesn't log in, solve CAPTCHAs or read private, quarantined or age-gated communities. It collects no
comments and no user data: the only thing it returns about a person is the public handle shown next
to their post. No avatars, no profile pages, no post history. Text bodies are cut to a 300-character
excerpt. Not affiliated with Reddit.

### FAQ

**Is this allowed?**
It collects the same public post listings your browser shows, for the keywords and subreddits you
choose. Only public listings are read, and no comment or user data is collected. It's built for
monitoring a search, not for copying Reddit. Reddit's robots.txt asks automated clients not to crawl
the site, and Reddit's Public Content Policy restricts commercial use of its content, so check that
your use fits Reddit's terms and your local law.

**Why did my monitoring run return nothing?**
Nothing new appeared since the last run. You get one row per keyword or subreddit with
`monitorStatus: NO_NEW_POSTS` and are charged only the start fee. On the very first run with "Seed
silently" on, the status is `SEEDED`.

**Does it respect Reddit's rate limits?**
Each request reads 100 posts, the most Reddit serves at once, so 1,000 posts is 10 requests.
Requests go through Apify's Unblocker proxy, which spreads them over many connections, so a
normal run never runs into Reddit's per-client limit and you don't have to manage delays or
retries. A page Reddit refuses is retried once on a fresh connection; if it is refused again, that
keyword or subreddit stops with `truncated: true` and you keep (and pay only for) what arrived.

**Why the Unblocker proxy?**
Reddit refuses its public listings to cloud and data-center addresses: a plain request from a
server gets a 403 block page, and old.reddit.com sends it to a login wall. Apify's Unblocker proxy is
what gets the same public listing a browser gets. It is included in the post price; there is
nothing to configure.

**Why is `truncated` true?**
Reddit refused a later page twice, or the run reached its page or time budget (Reddit answers slowly,
20 to 40 seconds per page) before your maximum. The posts collected up to then are delivered.

**How far back does it go?**
Reddit stops any listing at about 1,000 posts, so a busy subreddit's "new" feed covers days, a
quiet one months. For older posts use *Top* with a time window of a month, a year or all time.

**Can I get comments or a user's post history?**
No. This actor reads post listings only and never requests comments or user pages.

**Why are NSFW posts missing?**
"Skip NSFW posts" is on by default. Turn it off to include them.

**Can an AI agent call this?**
Yes, through the Apify MCP server or the API call shown above. Ask for "Reddit Search Scraper: New
Post Alerts by Keyword".

### Related actors

- [Google News Lookup](https://apify.com/accountable_eel/google-news-lookup): the same keyword
  watchlist, for news articles instead of Reddit posts.
- [X Profile Lookup](https://apify.com/accountable_eel/x-profile-lookup): public X (Twitter) profile
  stats for a list of accounts.
- [Vinted Scraper: New Listing & Price Drop Alerts](https://apify.com/accountable_eel/vinted-listing-lookup):
  the same only-what's-new monitoring, for second-hand listings.

# Actor input Schema

## `queries` (type: `array`):

One Reddit search per line, run across all of Reddit: a brand, a product, a topic or a phrase in quotes. Leave empty to watch only the subreddits below. No login required. Accepted formats: vinted, "apify actor", notion alternative. You're only charged for the ones we actually find — a miss costs nothing.

## `subreddits` (type: `array`):

One subreddit per line: Flipping, r/Flipping or a reddit.com/r/Flipping link all work. Each gets its own post feed in the sort order below. Leave empty to run only the search keywords above.

## `testRun` (type: `boolean`):

Turn this on to test your input on a small sample before running the full list. Turn it off to process everything.

## `onlyFound` (type: `boolean`):

Only keep rows where something was actually found. Misses are always free, whether or not you show them here.

## `includeKeywords` (type: `array`):

Optional. Keep a post only if its title or text contains at least one of these words (not case sensitive). Checked before you are billed. Leave empty to keep every post.

## `excludeKeywords` (type: `array`):

Optional. Drop any post whose title or text contains one of these words, before you are billed. Only the title and text are checked, never the subreddit or author name.

## `maxResults` (type: `integer`):

Up to 500. Caps how many posts you get (and pay for) from each search keyword and each subreddit separately. Reddit returns 100 posts per page, so 100 is one page per line.

## `minScore` (type: `integer`):

Optional. Skip posts with a lower score. Leave empty to keep every post. With monitoring on, a post that is too new to have the votes yet is delivered on a later run once it reaches this score.

## `excludeNsfw` (type: `boolean`):

On by default. Drops posts Reddit marks as NSFW (18+) before you are billed.

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

Newest first is the one to use for alerts. Top and Relevance use the time window below. Subreddits have no relevance order and use Top instead.

## `timeWindow` (type: `string`):

Only used with Top or Relevance, for example the week's top posts in a subreddit. Ignored for Newest first and Hot.

## `deltaMode` (type: `boolean`):

Turns each keyword and subreddit into an alert feed. A post counts as new when this watchlist has not returned it before. Posts already seen are dropped before you are billed, so a run with nothing new returns one summary row and costs only the start fee. Memory is kept per keyword and per subreddit, and a post not seen for 60 days is forgotten.

## `deltaName` (type: `string`):

Leave empty and one is derived from the sort order and time window, so a new-posts alert and a weekly top digest of the same subreddit keep separate memories. Type your own name to keep two schedules apart. Naming a watchlist with the checkbox above off returns every post but still marks 'Is this post new?' so you can filter in Sheets, n8n or Make.

## `skipFirstRun` (type: `boolean`):

The first run of a watchlist has nothing to compare with and returns up to your maximum. Turn this on to remember everything it finds without returning or billing it, so a Slack channel does not get a hundred messages on day one. Alerts start from the second run.

## `columns` (type: `array`):

Choose which pieces of information to include in each result row. All are included by default.

## `expandRows` (type: `boolean`):

When on, each post found gets its own row instead of being grouped under its search or subreddit. You're still only charged once per search or subreddit, no matter how many rows it produces.

## `maxConcurrency` (type: `integer`):

Parallel requests. Keep conservative — this target has no browser fallback, so getting blocked costs more than slow-and-steady.

## `proxyConfiguration` (type: `object`):

Apify Proxy config. Residential recommended for anti-bot-sensitive targets.

## Actor input object example

```json
{
  "queries": [
    "apify"
  ],
  "subreddits": [
    "webscraping"
  ],
  "testRun": false,
  "onlyFound": false,
  "includeKeywords": [],
  "excludeKeywords": [],
  "maxResults": 100,
  "excludeNsfw": true,
  "sort": "new",
  "timeWindow": "week",
  "deltaMode": false,
  "deltaName": "",
  "skipFirstRun": false,
  "columns": [
    "sourceType",
    "source",
    "postCount",
    "monitorStatus",
    "truncated",
    "posts",
    "id",
    "title",
    "subreddit",
    "author",
    "score",
    "upvoteRatio",
    "numComments",
    "createdAt",
    "permalinkUrl",
    "url",
    "isSelf",
    "selftextExcerpt",
    "linkFlairText",
    "isNsfw",
    "isNew",
    "firstSeenAt"
  ],
  "expandRows": true,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "UNBLOCKER"
    ]
  }
}
```

# 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 = {
    "queries": [
        "apify"
    ],
    "subreddits": [
        "webscraping"
    ],
    "includeKeywords": [],
    "excludeKeywords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("accountable_eel/reddit-search-lookup").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 = {
    "queries": ["apify"],
    "subreddits": ["webscraping"],
    "includeKeywords": [],
    "excludeKeywords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("accountable_eel/reddit-search-lookup").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 '{
  "queries": [
    "apify"
  ],
  "subreddits": [
    "webscraping"
  ],
  "includeKeywords": [],
  "excludeKeywords": []
}' |
apify call accountable_eel/reddit-search-lookup --silent --output-dataset

```

## MCP server setup

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

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/bpagyEkbfSmos4Tt6/builds/eeFVhcl3xR6lyuSnZ/openapi.json