# Reddit Brand Mention Monitor & Keyword Alerts (`johnatan029/reddit-brand-mention-monitor`) Actor

Monitor selected subreddits for genuinely new Reddit posts whose titles match your brand or keyword terms. Persistent per-term baselines prevent repeat billing, edited posts stay free, and every dimension gets free mention-velocity summaries. No Reddit login or API token.

- **URL**: https://apify.com/johnatan029/reddit-brand-mention-monitor.md
- **Developed by:** [Johnn Mottin](https://apify.com/johnatan029) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 new mentions

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

### Monitor genuinely new Reddit brand and keyword mentions

Watch the subreddits that matter to your audience and receive **only new Reddit posts whose titles match the brand or keyword terms you chose**.

This Actor is stateful. Every **term × subreddit** combination keeps its own persistent set of already-seen Reddit post IDs.

The first successful observation creates a **free baseline**. Later runs emit `NEW_MENTION` only when a matching post ID has not been seen before.

An edited Reddit post keeps the same post ID, so editing the title or metadata does not create another billable mention.

No Reddit login. No Reddit API token. No browser automation. No AI matching in runtime.

#### Key features

- **Stateful Reddit brand monitoring**
- **Keyword mention alerts**
- **Persistent term × subreddit baselines**
- **Genuinely new posts only**
- **Deduplication by Reddit post ID**
- **Edited posts are not re-billed**
- **Exact normalized title matching**
- **Case-insensitive matching**
- **Accent-insensitive matching**
- **Whole-term token-boundary matching**
- **Up to 25 terms**
- **Up to 15 subreddits**
- **Maximum 100 monitored dimensions**
- **1–3 recent feed pages per subreddit**
- **One subreddit fetch reused across every term**
- **Public author when available**
- **Reddit permalink**
- **Outbound URL when available**
- **Post creation timestamp**
- **Free TERM\_SUMMARY per dimension**
- **Free mention velocity**
- **Free RUN\_SUMMARY**
- **Controlled Reddit request pacing**
- **Pay Per Event**

> **Unofficial community Actor. Not affiliated with, sponsored by, or endorsed by Reddit, Inc.** The Actor reads public subreddit Atom/RSS feeds and processes public post metadata. Source behavior, availability, rate limits, and public feed depth can change.

***

### What this Actor is for

A Reddit scraper answers:

> What posts are visible right now?

A stateful monitor should answer:

> Which matching posts are new since I last checked?

This Actor is designed for:

- brand monitoring;
- competitor monitoring;
- product mentions;
- founder/company monitoring;
- PR and communications;
- social listening;
- customer research;
- community intelligence;
- buying-intent term monitoring inside selected communities;
- recurring Reddit dashboards;
- alert pipelines;
- research databases.

***

### Important: this monitors selected subreddits, not all of Reddit

You choose the communities that matter.

Example:

```text
r/technology
r/artificial
r/SaaS
r/startups
```

The Actor reads each selected subreddit's recent-post feed and matches your terms locally.

It does **not** claim to search every subreddit or every Reddit post.

This design makes the monitored scope explicit and avoids presenting a limited feed window as universal Reddit search coverage.

***

### Important: title matching only

Version 1 matches monitored terms against:

```text
post title
```

It does not match:

- comments;
- full self-post body;
- replies;
- usernames;
- flair;
- linked article content.

This is deliberate.

The current event contract stays deterministic and low-noise.

If your workflow needs comments or full post bodies, use a richer Reddit collection Actor instead.

***

### Exact normalized term matching

Before comparison, titles and terms are normalized by:

1. converting to lowercase;
2. removing accents;
3. replacing non-alphanumeric characters with spaces;
4. collapsing the resulting token boundaries.

The term is then matched as a whole normalized phrase.

Example:

```text
term:
AI

title:
Paid search tools
```

does **not** match just because:

```text
paid
```

contains the letters:

```text
ai
```

The comparison behaves like a token-boundary phrase match.

***

### No fuzzy matching or synonyms

The Actor does not automatically expand:

```text
JM Forge
```

into:

```text
jmforge
JM-Forge
Johnatan's company
automation company
```

unless normalization makes the literal term equivalent.

For synonyms, alternate brand names, abbreviations, or common misspellings, add them as separate terms.

This keeps every match explainable.

***

### First run creates a free baseline

Every new:

```text
term × subreddit
```

dimension starts with no state.

On the first successful read, matching post IDs are remembered but not emitted as new.

Example:

```text
term: Anthropic
subreddit: artificial

matching posts already in recent feed: 7
previous state: none
```

Result:

```text
baseline: true
NEW_MENTION: 0
```

If a new matching post appears later:

```text
baseline already exists
new post ID: 1wxyz12
previously seen: no
```

the Actor can emit:

```text
NEW_MENTION
```

***

### Adding a new term later

Suppose an existing Task already monitors:

```text
Anthropic
```

and you add:

```text
Claude
```

The existing Anthropic dimensions keep their state.

Each new Claude × subreddit dimension creates its own free baseline the first time it is successfully read.

***

### Adding a new subreddit later

The same principle applies.

If you add:

```text
r/LocalLLaMA
```

to an existing Task, every monitored term gets a new first-sight dimension for that subreddit.

Existing subreddit dimensions keep their prior state.

***

### Persistent deduplication

The primary identity is Reddit's post ID.

Example:

```text
fullname:
t3_1abcxyz

postId:
1abcxyz
```

The persistent state stores matching post IDs for each term × subreddit.

If the same post appears again in a later run:

```text
seenBefore
```

increases, but another `NEW_MENTION` is not created.

***

### Edited posts are not new mentions

A Reddit post can have a later:

```text
updatedAt
```

while retaining the same post ID.

This Actor treats:

```text
same postId
=
same mention
```

An edit does not create a second billable event.

This is a **new-post mention monitor**, not an edit-history monitor.

***

### Term label and state identity

A term can be entered as:

```json
{
  "term": "anthropic",
  "label": "Anthropic"
}
```

The label is normalized into the state/event slug.

Two different terms must not use labels that normalize to the same slug.

The revised validator rejects such a collision explicitly instead of silently sharing state.

Example of a collision:

```json
{
  "terms": [
    {
      "term": "Acme AI",
      "label": "Acme"
    },
    {
      "term": "Acme Cloud",
      "label": "ACME"
    }
  ]
}
```

Both labels normalize to:

```text
acme
```

Use distinct labels when the actual monitored terms are different.

***

### Who it's for

#### Brand and PR teams

Monitor communities where your customers, users, or industry already talk.

Use new mentions as an input to:

- media/community review;
- support escalation;
- reputation research;
- weekly reporting.

***

#### Founders and SaaS teams

Watch:

- company name;
- product name;
- competitor names;
- high-intent phrases.

Example terms:

```text
notion
linear
crm software
alternative to
```

Remember that matching occurs only in post titles.

***

#### Community teams

Monitor multiple communities without manually refreshing each subreddit.

***

#### Research teams

Build a stateful feed of newly appearing public posts around known terms.

***

#### Automation builders

Connect `NEW_MENTION` records to:

- Slack;
- Microsoft Teams;
- Discord;
- email workflows;
- n8n;
- Make;
- webhooks;
- Google Sheets;
- databases;
- BI tools;
- internal applications;
- downstream AI analysis.

***

### Data source

The Actor uses public subreddit Atom/RSS feeds in the form:

```text
https://www.reddit.com/r/<subreddit>/new.rss
```

It does not use Reddit OAuth or an authenticated account.

The current client can follow feed pagination with Reddit's `after` cursor.

***

### Request economy

One subreddit feed fetch is reused across **all terms** monitored in that subreddit.

Example:

```text
10 terms
1 subreddit
1 feed page
```

requires one initial subreddit feed request, not ten separate keyword requests.

With:

```text
10 terms
5 subreddits
1 page each
```

the normal source work is approximately:

```text
5 subreddit feed requests
```

before retries.

This is why the product has a separate:

```text
term × subreddit
```

state dimension without making one HTTP request per dimension.

***

### Request pacing

Reddit can rate-limit request bursts.

The client enforces a minimum spacing of:

```text
2.5 seconds
```

between Reddit requests.

That floor is clamped in code and cannot be lowered by user input.

Retryable conditions use controlled backoff.

A non-retryable block is not bypassed through aggressive identity rotation or other evasion logic.

***

### Input

#### Recommended example

```json
{
  "terms": [
    {
      "term": "anthropic",
      "label": "Anthropic"
    },
    {
      "term": "claude",
      "label": "Claude"
    }
  ],
  "subreddits": [
    "technology",
    "artificial"
  ],
  "maxPagesPerSubreddit": 1,
  "maxResults": 500,
  "proxyMode": "auto",
  "maxRuntimeMs": 300000
}
```

#### Input fields

| Field | Default | Description |
|---|---:|---|
| `terms` | required | Brands/keywords. String or `{ term, label }`. Maximum 25 entries. |
| `subreddits` | required | Communities to monitor. Maximum 15 entries. |
| `maxPagesPerSubreddit` | `1` | Recent feed pages per subreddit. Range: 1–3. |
| `maxResults` | `500` | Maximum billable `NEW_MENTION` records. Range: 1–5,000. |
| `proxyMode` | `auto` | `auto`, `residential`, or `none`. |
| `maxRuntimeMs` | `300000` | Hard runtime cap in milliseconds. |
| `debug` | `false` | Additional diagnostics. |

***

### Term input formats

Bare string:

```json
{
  "terms": [
    "anthropic",
    "claude"
  ]
}
```

Object with a display label:

```json
{
  "terms": [
    {
      "term": "anthropic",
      "label": "Anthropic"
    }
  ]
}
```

The `term` is the actual title-matching phrase.

The `label` controls the public display label and persistent term slug.

***

### Subreddit input formats

All of these normalize to the same subreddit:

```text
technology
r/technology
/r/technology
```

Subreddit names are deduplicated case-insensitively.

***

### Dimension cap

The persistent monitoring dimension count is:

```text
terms × subreddits
```

Maximum:

```text
100
```

Examples:

```text
10 terms × 5 subreddits = 50 dimensions
20 terms × 5 subreddits = 100 dimensions
25 terms × 15 subreddits = 375 dimensions → invalid
```

Split larger portfolios across separate Tasks.

***

### Request cap

The Actor also validates:

```text
subreddits × maxPagesPerSubreddit
```

against a hard request budget of:

```text
45
```

Example:

```text
15 subreddits × 3 pages = 45
```

Retries have their own controlled margin in the runtime guard.

***

### Proxy modes

#### `auto`

Default production mode.

Uses Apify proxy configuration without selecting a residential group.

#### `residential`

Uses Apify residential proxy infrastructure.

This can carry different platform infrastructure cost characteristics than the default route.

#### `none`

Direct connection.

Primarily useful for testing environments where direct Reddit requests work.

A direct route can be blocked; the Actor does not silently pretend that an unavailable source returned no mentions.

***

### Output

The default Dataset can contain:

```text
NEW_MENTION
TERM_SUMMARY
RUN_SUMMARY
```

***

### `NEW_MENTION`

This is the billable event record.

It is written only when:

- the term × subreddit dimension is past its first baseline;
- the post title matches the normalized term;
- the post has a stable Reddit post ID;
- that post ID is not already stored in that dimension's state;
- the result is admitted by runtime/spend limits.

#### Example

```json
{
  "recordType": "NEW_MENTION",
  "entityId": "listening:reddit:anthropic/1abcxyz",
  "source": "reddit",
  "term": "anthropic",
  "termLabel": "Anthropic",
  "postId": "1abcxyz",
  "fullname": "t3_1abcxyz",
  "title": "Anthropic launches a new developer feature",
  "subreddit": "technology",
  "author": "example_user",
  "url": "https://example.com/article",
  "permalink": "https://www.reddit.com/r/technology/comments/1abcxyz/example/",
  "createdAt": "2026-08-31T12:00:00.000Z",
  "observedAt": "2026-08-31T13:00:00.000Z"
}
```

***

### `NEW_MENTION` fields

| Field | Description |
|---|---|
| `recordType` | `NEW_MENTION`. |
| `entityId` | Stable JM Forge mention identity. |
| `source` | `reddit`. |
| `term` | Normalized term slug. |
| `termLabel` | User-facing term label. |
| `postId` | Reddit post ID used for deduplication. |
| `fullname` | Reddit fullname such as `t3_<id>`. |
| `title` | Public post title. |
| `subreddit` | Community returned by the feed. |
| `author` | Public author username when available. |
| `url` | Outbound link when the feed supplies one; otherwise the permalink. |
| `permalink` | Public Reddit post URL. |
| `createdAt` | Post publication timestamp. |
| `observedAt` | Actor observation timestamp. |

***

### `TERM_SUMMARY`

Every successfully processed term × subreddit dimension receives a free summary.

It can include:

```text
term
termLabel
subreddit
baseline
postsInWindow
matchesInWindow
newMentions
mentionsDelivered
seenBefore
feedWindowHours
mentionsPer24h
observedAt
```

This makes a quiet run visible without creating a billable mention event.

***

### Mention velocity

When the fetched feed contains at least two valid post timestamps:

```text
feedWindowHours
```

is calculated from:

```text
newest createdAt
minus
oldest createdAt
```

The Actor then calculates:

```text
mentionsPer24h
=
matchesInWindow / (feedWindowHours / 24)
```

#### Honest limitation

This is a deterministic rate calculated from the **fetched recent feed window**.

It is not Reddit-wide mention volume.

If the subreddit is so active that the read window is truncated, the number reflects only the fetched slice.

***

### `RUN_SUMMARY`

The final run summary is free.

It can include:

```text
recordsWritten
unitsRequested
unitsOk
unitsFailed
capReason
qualityAlert
sourceUnavailable
warnings
units
outcomeKind
billableRecords
freeRecords
baselineDimensions
httpRequests
http429
httpRetries
topSubredditsOverall
cost
pricingLabel
```

`topSubredditsOverall` represents the subreddits with the most **billable new mentions delivered in that run**.

***

### STATS

Operational diagnostics are also persisted in:

```text
STATS
```

in the default Key-Value Store.

Depending on the run, STATS can expose:

- HTTP requests;
- retries;
- 429 responses;
- 5xx responses;
- baseline dimensions;
- completed dimensions;
- failed dimensions;
- billable records;
- free records;
- source health;
- quality warnings;
- runtime;
- caps;
- cost metrics.

***

### Stateful storage

Each term × subreddit dimension keeps up to:

```text
5,000 matching post IDs
```

in bounded persistent state.

The most recent retained IDs win as state grows.

For typical subreddit/term monitoring, this provides a long deduplication horizon.

Extremely high-volume matching dimensions can eventually age older IDs out of bounded state.

***

### Feed depth

Each requested page can contain up to roughly:

```text
100 recent entries
```

and the Actor accepts:

```text
1–3 pages
```

per subreddit.

That means the monitoring window is finite.

A high-traffic subreddit can publish enough posts between schedules that an older matching post falls beyond the feed window before the Actor sees it.

For high-volume communities:

- use more feed pages;
- schedule more frequently;
- monitor fewer broad terms;
- inspect the free `feedWindowHours`.

***

### Scheduling

This Actor is intended for recurring execution.

Practical starting points:

```text
hourly
daily
```

depending on subreddit activity.

The first run creates the baseline.

Later runs deliver only unseen matching post IDs.

***

### Recommended scheduled workflow

1. Choose the subreddits that matter.
2. Add brand/keyword terms.
3. Run once to establish free baselines.
4. Save the input as an Apify **Task**.
5. Open **Schedules**.
6. Choose a cadence.
7. Route future `NEW_MENTION` records downstream.

Possible destinations:

- Slack;
- Teams;
- Discord;
- email workflows;
- Google Sheets;
- n8n;
- Make;
- webhooks;
- databases;
- dashboards;
- support/triage systems.

***

### Example competitor-monitoring input

```json
{
  "terms": [
    {
      "term": "notion",
      "label": "Notion"
    },
    {
      "term": "obsidian",
      "label": "Obsidian"
    }
  ],
  "subreddits": [
    "productivity",
    "Notion",
    "ObsidianMD"
  ],
  "maxPagesPerSubreddit": 2,
  "maxResults": 200
}
```

A downstream workflow can:

- notify a community team;
- save new posts to a database;
- send matching posts to a support queue;
- generate a weekly report;
- run sentiment/topic analysis downstream;
- compare mention velocity by community.

***

### API

Run the Actor through the Apify API:

```bash
curl -s "https://api.apify.com/v2/acts/<YOUR_USERNAME>~reddit-brand-mention-monitor/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "terms":[
      {"term":"anthropic","label":"Anthropic"},
      {"term":"claude","label":"Claude"}
    ],
    "subreddits":["technology","artificial"],
    "maxPagesPerSubreddit":1,
    "maxResults":200
  }'
```

Replace:

```text
<YOUR_USERNAME>
<YOUR_APIFY_TOKEN>
```

with your Apify account values.

***

### Integrations

Use with:

- Apify API;
- Tasks;
- Schedules;
- webhooks;
- n8n;
- Make;
- Google Sheets;
- Slack;
- Teams;
- Discord;
- databases;
- BI tools;
- internal applications;
- downstream AI agents.

***

### Pricing

This Actor uses **Pay Per Event**.

The billing model contains:

```text
apify-actor-start
new-mention
```

#### `apify-actor-start`

This is Apify's **synthetic start event**.

It is charged automatically by the platform when configured in the Actor's Pricing settings.

The Actor code does **not** manually call a custom start charge.

Do not create a second custom:

```text
actor-start
```

event for this Actor.

#### `new-mention`

This is the custom billable value event.

It is charged once for each delivered:

```text
NEW_MENTION
```

The Actor does not charge `new-mention` for:

- baseline matching posts;
- already-seen post IDs;
- edited posts with the same ID;
- non-matching posts;
- `TERM_SUMMARY`;
- `RUN_SUMMARY`.

The **Pricing** tab on the Actor page is always the authoritative source for current prices.

***

### What is free

Free by design:

```text
first baseline
re-seen matching posts
edited matching posts
TERM_SUMMARY
RUN_SUMMARY
```

A quiet scheduled run can therefore produce monitoring summaries without a `new-mention` result charge.

The synthetic Actor-start event can still apply.

***

### Cost control

Primary controls:

```text
terms
subreddits
maxPagesPerSubreddit
maxResults
proxyMode
maxRuntimeMs
```

#### Lower-cost monitoring

Use:

- fewer subreddits;
- one page when the feed window is sufficient;
- focused terms;
- default datacenter proxy;
- an explicit `maxResults`.

#### Deeper monitoring

Increasing pages widens the recent-feed window but also increases:

- source requests;
- runtime;
- proxy/compute usage.

***

### Run health

The Actor distinguishes source and input failures from legitimate quiet monitoring.

Possible controlled conditions include:

```text
SUBREDDIT_NOT_FOUND
SOURCE_BLOCKED
HTTP_RATE_LIMITED
HTTP_TIMEOUT
NETWORK_UNREACHABLE
API_CONTRACT_CHANGED
ALL_UNITS_FAILED
INVALID_INPUT
```

A failing subreddit does not automatically invalidate successfully processed subreddits.

If every supplied subreddit is not found, the run is classified as an input problem rather than a Reddit-wide outage.

***

### Honest limits

#### Title-only matching

Comments and post bodies are outside the current matching contract.

#### Selected communities only

This Actor does not claim all-Reddit search coverage.

#### Finite feed window

The Actor sees only the recent posts available in the pages it fetched.

#### Public feed depth can change

Reddit controls the number and behavior of entries returned by its feeds.

#### High-traffic subreddits need a suitable schedule

If posts roll past the feed window between runs, an unseen mention can be missed.

#### Exact terms only

No stemming, synonym expansion, fuzzy matching, or semantic similarity is performed.

#### Edited posts are intentionally not events

Same Reddit post ID means same mention.

#### State is per term × subreddit

The same Reddit post can legitimately be billable once for multiple independent monitored terms if its title matches multiple terms.

That is the product contract: each monitored term is a separate listening dimension.

#### The same post can also be independent across subreddits

Reddit crossposts are separate Reddit post IDs.

They can therefore become separate mentions.

#### No comments

The Actor does not collect or monitor comment threads.

#### No Reddit engagement metrics

The current RSS contract does not provide the richer score/comment metadata available through other Reddit data sources.

#### Proxy mode affects infrastructure

Residential proxy usage can have higher platform infrastructure cost than the default datacenter route.

#### Public source behavior can change

Reddit can change:

- rate limits;
- feed availability;
- XML shape;
- blocking behavior;
- pagination behavior.

The Actor fails explicitly on unexpected source shape instead of fabricating mention data.

#### No AI in runtime

Term matching and deduplication are deterministic.

***

### FAQ

#### Do I need a Reddit account?

No.

#### Do I need a Reddit API token?

No.

#### Does the Actor use Reddit OAuth?

No.

#### Does it use browser automation?

No.

#### What happens on the first run?

Every new term × subreddit dimension learns its currently matching post IDs as a free baseline.

#### Why did I get no `NEW_MENTION` on the first run?

That is expected.

Historical recent matches are not presented as novelty.

#### What happens if I add a new term?

That new term creates its own free baseline on every monitored subreddit.

#### What happens if I add a new subreddit?

Each term gets a new baseline for that subreddit.

#### Does it monitor comments?

No.

#### Does it match the post body?

No.

Title only.

#### Is matching case-sensitive?

No.

#### Does matching ignore accents?

Yes.

#### Does `AI` match `paid`?

No.

#### Can I add multiple spellings of a brand?

Yes.

Add them as separate terms with distinct labels/state identities where appropriate.

#### How many terms can I monitor?

Up to:

```text
25
```

input terms.

#### How many subreddits?

Up to:

```text
15
```

but the combined dimension count must remain at or below 100.

#### How many pages can I read?

Between:

```text
1
```

and:

```text
3
```

per subreddit.

#### Are edited posts charged again?

No.

#### Are summaries charged?

No.

#### Is a repeated matching post charged again?

No while its post ID remains in persistent state.

#### What does `mentionsPer24h` mean?

It is the number of matching posts in the fetched feed slice normalized to a 24-hour rate.

It is not Reddit-wide volume.

#### What happens if a subreddit does not exist?

The client treats an HTTP 404 as:

```text
SUBREDDIT_NOT_FOUND
```

and that subreddit/dimensions fail explicitly.

#### Can I schedule it?

Yes.

Hourly or daily are common starting points, depending on feed activity.

#### What am I charged for?

The synthetic Apify start event configured in Pricing plus genuinely new matching `NEW_MENTION` records delivered after baseline.

#### Is this affiliated with Reddit?

No.

This is an independent community Actor using public Reddit feeds.

***

### Support

For bugs, questions, or requested fields:

```text
johnatan291303@gmail.com
```

You can also use the **Issues** tab on the Actor page.

***

### Part of the JM Forge suite

Also from the same developer:

- **Brand News Monitor & GDELT Mention Alerts** — stateful global news monitoring.
- **Steam Review Monitor & Player Feedback Alerts** — stateful player-review monitoring.
- **Google, Bing & YouTube Autocomplete Trend Monitor** — stateful autocomplete-change monitoring.

JM Forge Actors remain independent tools.

Use this Actor for **new Reddit post mentions inside communities you explicitly choose**.

# Actor input Schema

## `terms` (type: `array`):

Brand names or keywords. Each entry is a string or { "term", "label" }. Matching is exact on normalized post titles (case/accents-insensitive, whole words only) — no fuzzy matching, no scoring.

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

The subreddits to monitor (with or without the r/ prefix). One feed fetch serves every term.

## `maxPagesPerSubreddit` (type: `integer`):

Each page holds up to 100 newest posts. More pages = deeper window, more requests.

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

Delivery fence: NEW\_MENTION events beyond this cap are neither delivered nor charged.

## `proxyMode` (type: `string`):

Apify proxy used for Reddit requests. "auto" (datacenter) is the proven default; "none" is for local testing only.

## `maxRuntimeMs` (type: `integer`):

Hard runtime fence (SpendGuard).

## `debug` (type: `boolean`):

Verbose per-dimension logging.

## Actor input object example

```json
{
  "terms": [
    {
      "term": "anthropic",
      "label": "Anthropic"
    },
    {
      "term": "claude",
      "label": "Claude"
    }
  ],
  "subreddits": [
    "technology",
    "artificial"
  ],
  "maxPagesPerSubreddit": 1,
  "maxResults": 100,
  "proxyMode": "auto",
  "maxRuntimeMs": 300000,
  "debug": false
}
```

# Actor output Schema

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

Default dataset containing NEW\_MENTION, TERM\_SUMMARY, and RUN\_SUMMARY records.

## `stats` (type: `string`):

STATS record with requests, retries, billing counters, source health, runtime, limits, and operational metrics.

# 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 = {
    "terms": [
        {
            "term": "anthropic",
            "label": "Anthropic"
        },
        {
            "term": "claude",
            "label": "Claude"
        }
    ],
    "subreddits": [
        "technology",
        "artificial"
    ],
    "maxPagesPerSubreddit": 1,
    "maxResults": 100,
    "proxyMode": "auto",
    "maxRuntimeMs": 300000,
    "debug": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("johnatan029/reddit-brand-mention-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 = {
    "terms": [
        {
            "term": "anthropic",
            "label": "Anthropic",
        },
        {
            "term": "claude",
            "label": "Claude",
        },
    ],
    "subreddits": [
        "technology",
        "artificial",
    ],
    "maxPagesPerSubreddit": 1,
    "maxResults": 100,
    "proxyMode": "auto",
    "maxRuntimeMs": 300000,
    "debug": False,
}

# Run the Actor and wait for it to finish
run = client.actor("johnatan029/reddit-brand-mention-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 '{
  "terms": [
    {
      "term": "anthropic",
      "label": "Anthropic"
    },
    {
      "term": "claude",
      "label": "Claude"
    }
  ],
  "subreddits": [
    "technology",
    "artificial"
  ],
  "maxPagesPerSubreddit": 1,
  "maxResults": 100,
  "proxyMode": "auto",
  "maxRuntimeMs": 300000,
  "debug": false
}' |
apify call johnatan029/reddit-brand-mention-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,johnatan029/reddit-brand-mention-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/mbNxpiG8ryzdfmSj7/builds/EyRTZEh1prbfk5HUa/openapi.json