# Reddit Keyword Monitor & Brand Alerts (`b2b_leads/reddit-keyword-monitor-brand-alerts`) Actor

Monitor Reddit for brand mentions, competitors & keywords in real time. Scan any subreddit or all of Reddit, get instant Slack/webhook alerts, and export clean JSON. No API key needed — fast, lightweight, and schedule-ready. Perfect for PR, lead gen, and competitor tracking.

- **URL**: https://apify.com/b2b\_leads/reddit-keyword-monitor-brand-alerts.md
- **Developed by:** [Chidubem Aneke](https://apify.com/b2b_leads) (community)
- **Categories:** Lead generation, Social media, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Keyword Monitor & Brand Alerts

#### Never miss a Reddit conversation about your brand, product, or competitors — again.

Reddit is where your customers speak freely: praising you, comparing you to rivals, asking for alternatives, and warning each other away from bad products. **This Actor turns those conversations into an actionable feed of alerts.** Give it your keywords, point it at the subreddits that matter (or all of Reddit), and get back clean, structured matches you can push straight into Slack, a spreadsheet, a CRM, or your own app.

**Outcome:** you find the mention, the lead, or the PR risk **while it's still fresh** — not days later when the thread already has 500 upvotes.

> ⚡ **Run it once for an instant sweep, or schedule it for always-on monitoring.** Zero API keys. No setup headaches. Results in seconds.

---

### What you get out of it

- 🎯 **Every relevant mention, none of the noise** — precise keyword matching with negative filters, minimum-upvote thresholds, and author allow/deny lists so your feed stays clean.
- 🔔 **Alerts the moment it matters** — each match can fire a webhook or a formatted Slack message with a one-click link to the thread.
- 🧠 **Analysis-ready data** — structured JSON with the matched keyword, a highlighted snippet, author, score, subreddit, and permalink. Drop it into a dashboard or an LLM with zero cleanup.
- 🔁 **No duplicate alerts** — scheduled mode remembers what it already sent, so you only ever see *new* conversations.
- 💸 **Cheap to run** — a lightweight, no-API-key engine runs on as little as **512 MB RAM**, so continuous monitoring costs pennies, not dollars.
- 🤖 **Built for automation & AI agents** — first-class Apify API and **MCP** support so LLMs and no-code tools can drive it directly.

---

### Who uses this and why

| You are… | The result you get |
|----------|--------------------|
| **Brand / PR team** | Catch praise, complaints, and crises the moment they surface — respond before they trend. |
| **Founder / marketer** | Turn "anyone know an alternative to X?" threads into warm leads. |
| **Competitive intelligence** | Track every mention of rival products, launches, and pricing complaints. |
| **Community / support** | Know when your product is discussed so you can jump in and help. |
| **Investor / analyst** | Monitor tickers, projects, and sentiment across finance and crypto subreddits. |
| **Agencies** | Run branded monitoring for every client from one schedule. |
| **Developers & AI agents** | A clean, documented data source for pipelines, apps, and LLM tools. |

---

### How it works (3 steps)

1. **Tell it what to watch** — add your keywords, brands, or phrases.
2. **Tell it where to watch** — pick specific subreddits, or scan **all of Reddit**.
3. **Choose how to run** — a one-off scan for instant results, or scheduled monitoring for continuous, deduplicated alerts.

That's it. Matches stream to your dataset as they're found and, optionally, to your webhook or Slack channel.

---

### Run modes

#### 🟢 One-off scan *(default)*
Runs once, scans the most recent posts/comments, returns every match, and **stops**. Perfect for research, one-time exports, and quick "who's talking about us right now?" checks.

#### 🔵 Scheduled monitor
Pair with the **Apify Scheduler** for always-on monitoring. The Actor remembers the newest item it has already seen per subreddit, so each run returns **only new matches** — no repeats, no duplicate alerts. Set it to run every 1–5 minutes for near-real-time coverage.

---

### Matching that actually stays relevant

- **Match modes** — `substring` (default), whole-`word` (avoids partial-word false positives), or full `regex` for power users.
- **Case sensitivity** — off by default; toggle on when case matters (e.g. ticker symbols).
- **Ignore keywords** — negative filters that drop a match even if a watch term appears (great for filtering out "job", "hiring", spam, etc.).
- **Title-only mode** — match on post titles only, for higher-signal alerts.
- **Minimum upvotes** — only surface matches with real traction.
- **Author allow / deny lists** — focus on specific users, or mute known bots and competitors.
- **NSFW control** — excluded by default for brand-safe feeds.

---

### Input reference

| Field | Type | Default | What it does |
|-------|------|---------|--------------|
| `keywords` | `string[]` | *(required)* | Brands, competitors, or phrases to watch. |
| `watchScope` | `string` | `"specific_subreddits"` | `"specific_subreddits"` or `"all_reddit"` (site-wide). |
| `subreddits` | `string[]` | `[]` | Communities to scan when scope is specific. |
| `stream` | `string` | `"both"` | `"posts"`, `"comments"`, or `"both"`. |
| `runMode` | `string` | `"once"` | `"once"` (scan & stop) or `"scheduled_monitor"` (dedupe across runs). |
| `matchMode` | `string` | `"substring"` | `"substring"`, `"word"`, or `"regex"`. |
| `caseSensitive` | `boolean` | `false` | Respect upper/lowercase when matching. |
| `ignoreKeywords` | `string[]` | `[]` | Skip a match if any of these appear. |
| `titleOnly` | `boolean` | `false` | Match post titles only (ignore body). |
| `minUpvotes` | `number` | `0` | Minimum upvotes required to emit a match. |
| `includeNsfw` | `boolean` | `false` | Include NSFW (over-18) posts. |
| `authorAllowlist` | `string[]` | `[]` | Only match these authors (empty = all). |
| `authorDenylist` | `string[]` | `[]` | Exclude these authors. |
| `lookback` | `number` | `100` | Newest items scanned per subreddit per stream (1–1000). Auto-paginates beyond one page. |
| `sinceId` | `string` | `""` | Manual cursor — only return items newer than this Reddit fullname. |
| `maxMatches` | `number` | `0` | Cap matches per run (0 = unlimited). |
| `webhookUrl` | `string` | `""` | Optional alert URL fired on each match (dataset is always written too). |
| `webhookFormat` | `string` | `"json"` | `"json"` or `"slack"`. |
| `includeRaw` | `boolean` | `false` | Attach the full raw Reddit object per row. |
| `proxyConfiguration` | `object` | US Residential | Apify proxy settings (recommended defaults). |

---

### Output — clean, structured, analysis-ready

Every match is one dataset row tagged `featureType: "keyword_monitor"`, with match context baked in:

| Field | Description |
|-------|-------------|
| `matchedKeywords` | Every watch-list keyword that hit this item. |
| `matchedSnippet` | A short excerpt highlighting the match. |
| `matchedIn` | `"title"`, `"body"`, or `"comment"`. |
| `fullname` | Reddit fullname — reuse as `sinceId` for manual incremental runs. |
| `subreddit`, `author`, `score`, `permalink` | Core context for triage. |
| Post fields | `title`, `selftext`, `url`, `numComments`, `nsfw`, media, awards, and more. |
| Comment fields | `body`, `depth`, `postId`, `parentId`, and more. |

**Pre-built dataset views:** `overview`, `matches`, `posts`, `comments` — switch views in the Apify console or via the API.

#### Example match

```json
{
  "featureType": "keyword_monitor",
  "matchedKeywords": ["openai"],
  "matchedSnippet": "…just tried openai's latest model and the results are…",
  "matchedIn": "title",
  "fullname": "t3_abc123",
  "title": "OpenAI release discussion",
  "subreddit": "technology",
  "author": "example_user",
  "score": 142,
  "numComments": 87,
  "permalink": "https://www.reddit.com/r/technology/comments/abc123/openai_release_discussion/",
  "createdAtISO": "2026-07-07T10:00:00.000Z",
  "scrapedAt": "2026-07-07T10:05:00.000Z"
}
````

***

### Copy-paste recipes

#### Brand monitoring on a schedule

```json
{
  "keywords": ["Acme Corp", "acme widget"],
  "watchScope": "specific_subreddits",
  "subreddits": ["technology", "gadgets", "startups"],
  "runMode": "scheduled_monitor",
  "stream": "both",
  "matchMode": "word",
  "lookback": 250,
  "minUpvotes": 1,
  "webhookUrl": "https://hooks.slack.com/services/YOUR/WEBHOOK/URL",
  "webhookFormat": "slack"
}
```

#### Competitor watch across all of Reddit

```json
{
  "keywords": ["CompetitorX", "competitor x alternative"],
  "watchScope": "all_reddit",
  "stream": "both",
  "ignoreKeywords": ["hiring", "job"],
  "lookback": 500,
  "maxMatches": 20
}
```

#### Lead & intent discovery

```json
{
  "keywords": ["looking for", "recommend", "alternative to"],
  "watchScope": "specific_subreddits",
  "subreddits": ["saas", "entrepreneur"],
  "stream": "comments",
  "matchMode": "substring",
  "minUpvotes": 2
}
```

***

### 🤖 Built for LLMs, AI agents & MCP

This Actor is designed to be driven by automation and AI — not just clicked in a dashboard. Inputs and outputs are fully schema-documented, so an LLM can call it correctly on the first try and consume the results without any parsing glue.

#### Why it's LLM-friendly

- **Self-describing schema** — every input field has a title, type, and description the model can read.
- **Predictable JSON output** — flat, consistently named fields with a `matchedSnippet` that's ready to feed straight into a prompt.
- **Deterministic filters** — keyword logic and thresholds are explicit, so an agent can reason about and tune results.

#### Use with Apify MCP (Model Context Protocol)

The [Apify MCP Server](https://mcp.apify.com) exposes this Actor as a callable tool for MCP-compatible clients such as **Claude Desktop, Cursor, VS Code, and ChatGPT**. Once connected, an assistant can search for, configure, and run the Actor and read its results — all in natural language.

**Connect via the hosted MCP endpoint:**

```
https://mcp.apify.com
```

**Example MCP client config:**

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_API_TOKEN"
      }
    }
  }
}
```

Then just ask your assistant, for example:

> *"Use the Reddit Keyword Monitor to check r/technology and r/startups for any new mentions of 'Acme Corp' in the last 100 posts and comments, and summarize the sentiment."*

The agent fills in the input, runs the Actor, and reads the matches back automatically.

#### Run it programmatically (Apify API)

Start a run and get results via the standard Apify REST API — ideal for backends, cron jobs, and agent tools:

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR_USERNAME~reddit-keyword-monitor/runs?token=YOUR_APIFY_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "keywords": ["openai"],
    "watchScope": "specific_subreddits",
    "subreddits": ["technology", "artificial"],
    "stream": "both",
    "lookback": 100
  }'
```

Fetch the matches from the run's dataset:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_APIFY_API_TOKEN"
```

***

### Alerts: Slack & webhooks

Set `webhookUrl` to get notified on **every match**. Matches are always saved to the dataset first, and the webhook fires **in addition** — so you get both a permanent record and a real-time ping.

- **`webhookFormat: "json"`** — a compact JSON payload with keywords, snippet, subreddit, and permalink.
- **`webhookFormat: "slack"`** — a ready-to-post Slack message with a **"View on Reddit"** button.

**Slack in 4 steps:**

1. Create an [Incoming Webhook](https://api.slack.com/messaging/webhooks) in your Slack workspace.
2. Paste the URL into `webhookUrl`.
3. Set `webhookFormat` to `"slack"`.
4. Schedule the Actor — matches land in your channel instantly.

You can also use **native Apify webhooks** to push the whole dataset to your backend when a run finishes.

***

### Scheduling & deduplication

For always-on monitoring, set `runMode` to `"scheduled_monitor"` and add an Apify Schedule (e.g. every 1–5 minutes).

- **Remembers position automatically** — the newest seen item per subreddit is stored between runs.
- **Only new matches** — no repeats, no duplicate alerts.
- **Manual control** — pass `sinceId` to start from a specific point; it's merged with saved state (the newer boundary wins).

**Tip:** for scheduled runs, leave `sinceId` empty and let the Actor handle dedupe for you.

***

### Popular use cases

- **Brand & reputation monitoring** — catch mentions before they trend.
- **Competitor intelligence** — track launches, complaints, and comparisons.
- **Lead & intent discovery** — surface buyers actively asking for solutions.
- **Community & support** — jump into threads about your product early.
- **Crypto & finance pulse** — watch tickers and projects across trading subreddits.
- **Crisis detection** — combine ignore-keywords and upvote thresholds to cut noise.

***

### Integrations

- **Apify Scheduler** — cron-style runs at any interval.
- **Apify Webhooks** — push results to your backend on run finish.
- **Slack** — per-match alerts via `webhookUrl`.
- **Zapier / Make** — webhook → spreadsheet, email, CRM, and 1000s of apps.
- **Google Sheets** — sync the dataset or route via webhook middleware.
- **Apify MCP & API** — for AI agents, LLM tools, and custom code.

***

### FAQ

**Do I need a Reddit API key or developer account?**
No. It works out of the box with zero setup.

**Will I get duplicate alerts?**
Only if you want them. In `scheduled_monitor` mode, dedupe is automatic — you only ever see new matches. One-off runs scan fresh each time.

**Can I monitor all of Reddit at once?**
Yes — set `watchScope` to `"all_reddit"`.

**How fast can I schedule it?**
Every 1–5 minutes works great for near-real-time monitoring.

**Is it expensive to run continuously?**
No — it's lightweight and runs on as little as 512 MB RAM, so continuous monitoring stays cheap.

***

### 📬 Need a custom scraper or web app? Let's build it.

I'm **DrunkCodes** — I build custom data and software solutions, and I'm available for freelance and contract work. If this Actor is close to what you need but not quite, or you have something entirely different in mind, reach out.

**I can help you with:**

- 🕸️ **Custom scrapers & Apify Actors** — any website, marketplace, social platform, or API, built fast and built to last.
- 🤖 **Data pipelines & automations** — monitoring, alerting, enrichment, and delivery into your tools of choice.
- 🌐 **Web apps of any kind** — dashboards, internal tools, SaaS products, landing pages, and full-stack builds.
- 🔌 **Integrations** — connect data sources, LLMs, MCP tools, Slack, CRMs, and more.

**Get in touch:**

- 📧 **Email:** <dubem115@gmail.com>
- 💻 **GitHub:** [github.com/DrunkCodes](https://github.com/DrunkCodes)

Tell me what you're trying to achieve and I'll help you get there. No project too big or too small.

***

### License

ISC

# Actor input Schema

## `keywords` (type: `array`):

Required. Brand names, competitors, product terms, or phrases to watch for in Reddit posts and comments.

## `matchMode` (type: `string`):

How keywords are matched: substring (default), whole-word boundary, or regex pattern per keyword.

## `caseSensitive` (type: `boolean`):

When enabled, keyword matching respects upper/lowercase. Off by default (case-insensitive).

## `ignoreKeywords` (type: `array`):

Negative filters — if any of these appear in the text, the item is skipped even when a watch keyword matches.

## `watchScope` (type: `string`):

Choose specific subreddits or scan all of Reddit site-wide via r/all.

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

Subreddit names or URLs to scan. Only used when watch scope is "Specific subreddits" — add at least one.

## `stream` (type: `string`):

Whether to scan new comments, new posts, or both for keyword matches.

## `runMode` (type: `string`):

One-off: scan the lookback window, return matches, and stop (default). Scheduled monitor: remember position between runs — use with Apify Scheduler for continuous alerts.

## `lookback` (type: `integer`):

Number of newest posts/comments to scan per subreddit per stream (1–1000). The Actor auto-paginates beyond a single page. Higher values give deeper coverage but cost slightly more per run.

## `sinceId` (type: `string`):

Optional Reddit fullname (e.g. t1\_abc123 or t3\_xyz). In scheduled monitor mode, combined with persisted state so only newer items are returned.

## `maxMatches` (type: `integer`):

Stop after this many matches in a single run. 0 = unlimited.

## `titleOnly` (type: `boolean`):

For posts, match keywords in the title only (ignore selftext/body). Comments are always matched on body text.

## `minUpvotes` (type: `integer`):

Only emit matches with at least this many upvotes. Set to 0 to disable.

## `includeNsfw` (type: `boolean`):

Include posts marked over\_18 (NSFW). Off by default for brand-safe monitoring.

## `authorAllowlist` (type: `array`):

If set, only posts/comments from these usernames are considered. Empty = all authors allowed.

## `authorDenylist` (type: `array`):

Usernames to exclude from matching (spam bots, competitors, etc.).

## `webhookUrl` (type: `string`):

Optional URL to POST an alert on each match. Matches are always saved to the dataset (required for billing) — webhooks fire in addition, not instead.

## `webhookFormat` (type: `string`):

json = compact JSON payload; slack = Slack-compatible message with link button.

## `includeRaw` (type: `boolean`):

Attach the full raw Reddit object under the raw field (larger output).

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

Use Apify Proxy with US Residential for best results on Reddit runs.

## Actor input object example

```json
{
  "keywords": [
    "openai",
    "your brand"
  ],
  "matchMode": "substring",
  "caseSensitive": false,
  "ignoreKeywords": [],
  "watchScope": "specific_subreddits",
  "subreddits": [
    "technology",
    "startups"
  ],
  "stream": "both",
  "runMode": "once",
  "lookback": 250,
  "sinceId": "",
  "maxMatches": 0,
  "titleOnly": false,
  "minUpvotes": 0,
  "includeNsfw": false,
  "authorAllowlist": [],
  "authorDenylist": [],
  "webhookUrl": "",
  "webhookFormat": "json",
  "includeRaw": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `allResults` (type: `string`):

Complete dataset with every field from matched posts and comments.

## `overview` (type: `string`):

Compact table — subreddit, matched keywords, snippet, author, score, and permalink.

## `matches` (type: `string`):

Every keyword monitor match with match metadata.

## `posts` (type: `string`):

Matched post rows only.

## `comments` (type: `string`):

Matched comment rows only.

# 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 = {
    "keywords": [
        "openai",
        "your brand"
    ],
    "subreddits": [
        "technology",
        "startups"
    ],
    "lookback": 250
};

// Run the Actor and wait for it to finish
const run = await client.actor("b2b_leads/reddit-keyword-monitor-brand-alerts").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 = {
    "keywords": [
        "openai",
        "your brand",
    ],
    "subreddits": [
        "technology",
        "startups",
    ],
    "lookback": 250,
}

# Run the Actor and wait for it to finish
run = client.actor("b2b_leads/reddit-keyword-monitor-brand-alerts").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keywords": [
    "openai",
    "your brand"
  ],
  "subreddits": [
    "technology",
    "startups"
  ],
  "lookback": 250
}' |
apify call b2b_leads/reddit-keyword-monitor-brand-alerts --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=b2b_leads/reddit-keyword-monitor-brand-alerts",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Keyword Monitor & Brand Alerts",
        "description": "Monitor Reddit for brand mentions, competitors & keywords in real time. Scan any subreddit or all of Reddit, get instant Slack/webhook alerts, and export clean JSON. No API key needed — fast, lightweight, and schedule-ready. Perfect for PR, lead gen, and competitor tracking.",
        "version": "0.0",
        "x-build-id": "uphfJ0ZDxSs7t9Z1a"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/b2b_leads~reddit-keyword-monitor-brand-alerts/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-b2b_leads-reddit-keyword-monitor-brand-alerts",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/b2b_leads~reddit-keyword-monitor-brand-alerts/runs": {
            "post": {
                "operationId": "runs-sync-b2b_leads-reddit-keyword-monitor-brand-alerts",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/b2b_leads~reddit-keyword-monitor-brand-alerts/run-sync": {
            "post": {
                "operationId": "run-sync-b2b_leads-reddit-keyword-monitor-brand-alerts",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Required. Brand names, competitors, product terms, or phrases to watch for in Reddit posts and comments.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "matchMode": {
                        "title": "Match mode",
                        "enum": [
                            "substring",
                            "word",
                            "regex"
                        ],
                        "type": "string",
                        "description": "How keywords are matched: substring (default), whole-word boundary, or regex pattern per keyword.",
                        "default": "substring"
                    },
                    "caseSensitive": {
                        "title": "Case sensitive matching",
                        "type": "boolean",
                        "description": "When enabled, keyword matching respects upper/lowercase. Off by default (case-insensitive).",
                        "default": false
                    },
                    "ignoreKeywords": {
                        "title": "Ignore keywords",
                        "type": "array",
                        "description": "Negative filters — if any of these appear in the text, the item is skipped even when a watch keyword matches.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "watchScope": {
                        "title": "Watch scope",
                        "enum": [
                            "specific_subreddits",
                            "all_reddit"
                        ],
                        "type": "string",
                        "description": "Choose specific subreddits or scan all of Reddit site-wide via r/all.",
                        "default": "specific_subreddits"
                    },
                    "subreddits": {
                        "title": "Subreddits",
                        "type": "array",
                        "description": "Subreddit names or URLs to scan. Only used when watch scope is \"Specific subreddits\" — add at least one.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "stream": {
                        "title": "Content stream",
                        "enum": [
                            "posts",
                            "comments",
                            "both"
                        ],
                        "type": "string",
                        "description": "Whether to scan new comments, new posts, or both for keyword matches.",
                        "default": "both"
                    },
                    "runMode": {
                        "title": "Run mode",
                        "enum": [
                            "once",
                            "scheduled_monitor"
                        ],
                        "type": "string",
                        "description": "One-off: scan the lookback window, return matches, and stop (default). Scheduled monitor: remember position between runs — use with Apify Scheduler for continuous alerts.",
                        "default": "once"
                    },
                    "lookback": {
                        "title": "Lookback items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Number of newest posts/comments to scan per subreddit per stream (1–1000). The Actor auto-paginates beyond a single page. Higher values give deeper coverage but cost slightly more per run.",
                        "default": 100
                    },
                    "sinceId": {
                        "title": "Since fullname (incremental cursor)",
                        "type": "string",
                        "description": "Optional Reddit fullname (e.g. t1_abc123 or t3_xyz). In scheduled monitor mode, combined with persisted state so only newer items are returned.",
                        "default": ""
                    },
                    "maxMatches": {
                        "title": "Max matches per run",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Stop after this many matches in a single run. 0 = unlimited.",
                        "default": 0
                    },
                    "titleOnly": {
                        "title": "Match post titles only",
                        "type": "boolean",
                        "description": "For posts, match keywords in the title only (ignore selftext/body). Comments are always matched on body text.",
                        "default": false
                    },
                    "minUpvotes": {
                        "title": "Minimum upvotes",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only emit matches with at least this many upvotes. Set to 0 to disable.",
                        "default": 0
                    },
                    "includeNsfw": {
                        "title": "Include NSFW posts",
                        "type": "boolean",
                        "description": "Include posts marked over_18 (NSFW). Off by default for brand-safe monitoring.",
                        "default": false
                    },
                    "authorAllowlist": {
                        "title": "Author allowlist",
                        "type": "array",
                        "description": "If set, only posts/comments from these usernames are considered. Empty = all authors allowed.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "authorDenylist": {
                        "title": "Author denylist",
                        "type": "array",
                        "description": "Usernames to exclude from matching (spam bots, competitors, etc.).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "webhookUrl": {
                        "title": "Webhook URL",
                        "type": "string",
                        "description": "Optional URL to POST an alert on each match. Matches are always saved to the dataset (required for billing) — webhooks fire in addition, not instead.",
                        "default": ""
                    },
                    "webhookFormat": {
                        "title": "Webhook format",
                        "enum": [
                            "json",
                            "slack"
                        ],
                        "type": "string",
                        "description": "json = compact JSON payload; slack = Slack-compatible message with link button.",
                        "default": "json"
                    },
                    "includeRaw": {
                        "title": "Include raw Reddit JSON",
                        "type": "boolean",
                        "description": "Attach the full raw Reddit object under the raw field (larger output).",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy settings",
                        "type": "object",
                        "description": "Use Apify Proxy with US Residential for best results on Reddit runs.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
