How to Use n8n with ._Template 30 Competitor Mentioned Alert Notes

Your competitors are shipping features, dropping prices, and getting mentioned in communities where your prospects hang out — and you find out weeks later, if at all. By the time a Slack teammate forwards you a thread, the conversation has moved on. Manual monitoring doesn't scale: nobody has time to refresh Reddit, Hacker News, review sites, and Twitter/X all day. The result is that competitive intelligence becomes reactive gossip instead of a reliable operational signal.

This guide shows you how to build a Competitor Mention Alert system in n8n that watches the web for every time a rival is named, filters out the noise, and pushes a clean, contextual notification to your team in real time. No paid monitoring SaaS, no analyst headcount — just a workflow you own and control.

The problem: competitive signal is scattered and perishable

Competitive mentions live in a dozen disconnected places: subreddits, HN threads, G2 and Capterra reviews, YouTube comments, changelog RSS feeds, and social posts. Each source has its own format, its own polling rhythm, and its own noise profile. A founder who tries to track all of this manually ends up doing one of two things — checking obsessively and burning hours, or checking rarely and missing the moments that matter.

The signal is also perishable. A prospect asking "has anyone compared us to [Competitor]?" in a community thread is a sales opportunity that expires in hours. A competitor announcing a price cut is a positioning decision you need to make today, not next sprint. What you need is a system that collapses all these sources into one filtered stream and alerts you the moment something relevant surfaces.

The solution: a single n8n workflow as your monitoring backbone

n8n is ideal for this because it's an orchestration layer — it connects the fragmented sources, normalizes their output, applies your filtering logic, and fans out notifications, all in one visual workflow. Instead of stitching together scripts and cron jobs, you get a single canvas that polls every source on a schedule, deduplicates mentions so you're not alerted twice, and routes each hit to the right channel.

The core architecture is simple: a Schedule Trigger fires the workflow, several HTTP Request and RSS nodes pull raw data from each source, an IF or Filter node keeps only genuine mentions, a data store checks whether you've seen this item before, and a notification node delivers what survives. Because it's self-hosted (or on n8n Cloud), you control the polling frequency and the keyword logic without per-seat SaaS pricing.

Step-by-step setup in n8n

Here's how to assemble the workflow node by node. This assumes n8n version 1.x with the standard node set.

1. Schedule Trigger. Add a Schedule Trigger node as your entry point. Set it to run on a Cron Expression — every 15 minutes (*/15 * * * *) is a good balance between freshness and API politeness. Tighter intervals risk rate limits on public endpoints.

2. Pull the sources. Add a parallel branch for each source:

• Reddit: an HTTP Request node hitting https://www.reddit.com/search.json?q=%22CompetitorName%22&sort=new&limit=25. Set the Response Format to JSON and add a descriptive User-Agent header so Reddit doesn't throttle you.
• Hacker News: an HTTP Request to the Algolia API — https://hn.algolia.com/api/v1/search_by_date?query=CompetitorName&tags=(story,comment). This returns structured, timestamped hits with no auth needed.
• RSS sources (blogs, changelogs, review feeds): use the dedicated RSS Read node, one per feed URL.
• Twitter/X or others: an HTTP Request node against whichever API you have credentials for, using n8n's Header Auth credential type to store the bearer token securely.

3. Normalize with a Set node. After each source, drop in a Set (or Edit Fields) node that maps every source's idiosyncratic fields into a common shape: title, url, source, content, published_at, and a unique id. This normalization is the single most important step — it lets everything downstream treat a Reddit post and an HN comment identically.

4. Merge the streams. Feed all normalized branches into a Merge node set to Append mode. You now have one unified list of candidate mentions.

5. Filter for real relevance. Add a Filter node with an expression that keeps only meaningful hits. A basic version checks that the competitor name appears as a whole word and excludes obvious noise:

{{ $json.content.toLowerCase().includes('competitorname') && !$json.content.toLowerCase().includes('unrelated_homonym') }}

For sharper filtering, insert an AI Agent or Basic LLM Chain node here and prompt it to classify each mention as "buying-intent," "complaint," "feature-comparison," or "irrelevant" — then filter on that label. This turns a keyword firehose into prioritized intelligence.

6. Deduplicate. Mentions reappear across polls, so you must suppress repeats. Use the Remove Duplicates node keyed on the id or url field, or wire up a small persistence layer: a Postgres/Google Sheets node that stores every seen id, with an IF node that only proceeds when the id isn't already recorded. Persistence survives restarts; the built-in node is simpler but memory-scoped.

7. Deliver the alert. Route survivors to a Slack, Telegram, or Send Email node. Compose the message with an expression so each alert is scannable:

🔔 *{{ $json.source }}* mention: {{ $json.title }}\n{{ $json.url }}

Use Slack Block Kit formatting if you want clickable buttons to jump straight to the thread. Save the workflow, activate it, and your monitoring backbone is live.

The benefits: from reactive to operational

Once this runs, competitive intelligence stops being a chore and becomes infrastructure. Your sales team gets pinged the moment a prospect asks for a comparison, and can join the conversation while it's warm. Product and marketing see competitor launches within the hour, not the news cycle. Because everything flows through one workflow, you have a single audit trail of every mention — searchable in your data store and reusable for quarterly competitive reviews.

The economics matter too. Dedicated monitoring platforms charge hundreds of dollars a month and still don't cover niche communities. A self-hosted n8n workflow costs you the compute it runs on and adapts to any source with an API or RSS feed. When a new channel becomes important, you add one branch — you don't renegotiate a contract.

Common pitfalls and how to avoid them

Rate limiting. The fastest way to break this workflow is hammering public endpoints. Keep your Schedule Trigger at 15 minutes or slower, set a realistic User-Agent, and add a Loop Over Items node with a small wait if you're iterating over many queries. Reddit and HN will silently return errors if you're too aggressive.

Skipping deduplication. Without a dedup step, every poll re-alerts on the same mentions and your team mutes the channel within a day. Build the persistence layer early — it's the difference between a tool people trust and one they ignore.

Over-broad keywords. Short or generic competitor names generate constant false positives. Use whole-word matching, exclude known homonyms, and lean on the LLM classifier node when the name is ambiguous. Precision beats recall here; a noisy alert channel is worse than none.

Storing secrets in nodes. Never paste API tokens directly into HTTP Request URLs or fields. Use n8n's Credentials system (Header Auth, OAuth2) so keys are encrypted and reusable, and so your workflow export doesn't leak them.

No error handling. A single source going down shouldn't kill the whole run. Attach an Error Trigger workflow or set individual nodes to "Continue On Fail" so one flaky feed doesn't block the rest. Monitor your executions list weekly to catch silent breakage before it costs you a signal.

Start with two sources and one competitor, confirm the alerts are clean and non-duplicated, then expand. Within a week you'll have a competitive radar that runs itself — and you'll wonder how you operated without it.