# Discourse Forum Monitor — New Topics & Replies (`dev_web_col/discourse-monitor`) Actor

Monitor any Discourse community for brand mentions, new topics, replies and trending threads. Get only what changed since your last run, not the whole forum.

- **URL**: https://apify.com/dev\_web\_col/discourse-monitor.md
- **Developed by:** [Diseño Web de Colombia](https://apify.com/dev_web_col) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 change detecteds

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

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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

## Discourse Forum Monitor — New Topics & Replies

**Know the moment someone mentions your product in a community — without reading the forum.**

Almost every developer tool and SaaS company runs its community on Discourse: OpenAI, Docker, Home Assistant, Cloudflare, Ghost, Rclone, and thousands more. This actor watches the ones you pick and reports **only what changed** since your last run.

| Signal | What it means |
|---|---|
| 🆕 **New topic** | Someone started a thread. If you're watching a keyword, they just mentioned you |
| 💬 **New replies** | The thread is alive — and how many posts were added |
| ✅ **Answer accepted** | The question got resolved |
| 📈 **Trending** | Views are spiking on an existing thread |
| 🔒 **Closed** | Moderators locked it |
| ❌ **Removed** | It's gone |

If nothing changed, you get nothing and you pay nothing per result.

### Two ways to use it

**Brand monitoring** — give it keywords and it watches every mention across every forum you list:

```json
{
  "forumUrls": ["community.openai.com", "meta.discourse.org"],
  "keywords": ["your-product", "competitor-name"],
  "monitorKey": "brand-watch"
}
```

**Community pulse** — leave keywords empty and it watches the forum's recent activity:

```json
{
  "forumUrls": ["community.openai.com"],
  "maxPages": 3,
  "trackSignals": ["new_topic", "trending"]
}
```

### Why not just scrape the forum

There are Discourse scrapers already. They hand you the same 500 topics every run and leave you to work out what's different. For a daily schedule that's 500 rows you already had, every day.

```
Run over 2 forums → 100 topics watched → 3 rows returned:
  [new_topic  ] New Realtime API voices and cache pricing
  [new_replies] Realtime API updates — WebRTC        +3 replies
  [answered   ] Anyone know the pricing of full o1 image
```

You pay for 3 rows, not 100. The comparison happens against a snapshot stored in **your own** Apify account.

### Built for schedules

Set it to run hourly or daily and let it report.

- **DevRel & community managers** — never miss a question about your product
- **Marketing** — track how a competitor is discussed, in their own community
- **Support teams** — catch the unanswered thread before it becomes a complaint
- **Researchers** — build a real time series of community activity

### First run is free

The first run records the current state as your baseline and **charges nothing per result**. It returns a 25-row sample so you can see the data shape. From the second run onward you see and pay for changes only.

### Running several watchlists

`monitorKey` is the memory. Different keys, independent histories:

```json
{ "monitorKey": "our-brand",  "keywords": ["acme"] }
{ "monitorKey": "competitor", "keywords": ["globex"] }
```

Keep the key **stable**. Change it and you start a fresh baseline.

### Just need the topics right now?

Set **`oneShot: true`** and it returns the **current** topics instead of what changed — no history, no waiting for a second run.

```json
{ "oneShot": true, "forumUrls": ["community.openai.com"], "keywords": ["pricing"] }
```

Use it for a one-off lookup, to see real data before committing to a schedule, or when calling from an AI agent. It never touches your saved monitoring history, so it is safe to run against a `monitorKey` you already use.

### Honest limits

- **Keyword search does not return view counts.** Discourse's `search.json` omits them, so the `trending` signal and the `minViews` filter only work when watching recent topics (no keywords).
- Keyword search returns up to 50 topics per keyword per forum.
- Changing `maxPages` or your keyword list between runs changes what is being watched, which shows up as a burst of new and removed topics. Keep them stable.
- On `removed` topics only the stored summary survives — the forum no longer serves them.
- Private categories and login-walled forums are invisible. Only public content is read.

### Where the data comes from

The same public JSON endpoints the forum's own front end uses: `/latest.json` for recent topics and `/search.json` for keyword search. No login, no API key, no scraping of rendered HTML. No personal data beyond the public author username of the last post.

# Actor input Schema

## `oneShot` (type: `boolean`):

Return the CURRENT topics instead of what changed. Use this for a single lookup or from an AI agent — the monitor needs two runs before it has anything to compare. It never touches your saved history.

## `forumUrls` (type: `array`):

Just the domain: community.openai.com, meta.discourse.org, forum.rclone.org. Almost every developer tool and SaaS community runs Discourse. This actor watches the forums you choose; it does not discover them.

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

Watch only topics mentioning these words — your product, a competitor, a feature. Leave empty to watch the forum's recent topics instead.

## `monitorKey` (type: `string`):

Keep this the same across runs — it is how the actor remembers what it already saw. Use a different name for an independent watchlist.

## `trackSignals` (type: `array`):

Leave empty to get everything. New topic and new replies are what you usually want for brand monitoring.

## `maxPages` (type: `integer`):

Only when not using keywords. Each page is 30 topics. Keep it stable across runs.

## `minViews` (type: `integer`):

Ignore topics below this view count. Views are only available when watching recent topics, not keyword search.

## `categoryIds` (type: `array`):

Only watch these forum categories. Find the ID in the category URL. Leave empty for all.

## `tags` (type: `array`):

Only watch topics carrying at least one of these tags. Leave empty for all.

## `maxChanges` (type: `integer`):

Safety cap. You are charged per change returned.

## `resetBaseline` (type: `boolean`):

Forget everything seen before and take a fresh baseline. The baseline run is never charged per result.

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

Optional. Discourse forums are usually reachable without a proxy, but a busy schedule across many forums may need one.

## Actor input object example

```json
{
  "oneShot": false,
  "forumUrls": [
    "community.openai.com",
    "meta.discourse.org"
  ],
  "keywords": [
    "pricing"
  ],
  "monitorKey": "default",
  "trackSignals": [],
  "maxPages": 3,
  "categoryIds": [],
  "tags": [],
  "maxChanges": 5000,
  "resetBaseline": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `changes` (type: `string`):

One dataset item per topic that changed.

# 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 = {
    "forumUrls": [
        "community.openai.com",
        "meta.discourse.org"
    ],
    "keywords": [
        "pricing"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("dev_web_col/discourse-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 = {
    "forumUrls": [
        "community.openai.com",
        "meta.discourse.org",
    ],
    "keywords": ["pricing"],
}

# Run the Actor and wait for it to finish
run = client.actor("dev_web_col/discourse-monitor").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 '{
  "forumUrls": [
    "community.openai.com",
    "meta.discourse.org"
  ],
  "keywords": [
    "pricing"
  ]
}' |
apify call dev_web_col/discourse-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/KRl5CkxlmE4WcB3Ia/builds/gMxM8ZYjBib4BKWZA/openapi.json