Automate Competitor Monitoring and Market Tracking with n8n

What Competitor Monitoring Actually Catches

A competitor changed their pricing on a Tuesday. You found out the following Monday when a prospect mentioned it during a demo. That gap, 6 days of operating on stale information, is the real cost of quarterly manual competitive research.

n8n competitor monitoring workflows close that gap. They run on a schedule, hit competitor URLs, compare the result to a stored baseline, and fire an alert the moment something changes. No manual checks needed. No dashboards to refresh.

Here's what the workflows can track automatically:

• Pricing page changes, including partial tier updates and trial length adjustments
• Landing page copy rewrites, repositioning language, and new feature claims
• Job postings shifting toward engineering or sales roles (a forward signal about product direction)
• Ad creatives changing in the Facebook Ad Library or Google Transparency Center
• New product or plan pages appearing on a competitor's site
• Review sentiment shifts on G2 or Trustpilot following a major release

Some of these run daily. Job posting trend analysis works better on a weekly cadence.

The n8n Competitor Monitoring Pipeline

The core structure is three stages:

Schedule Trigger
  → HTTP Request (fetch competitor URL as string)
  → Code node (normalize, extract, hash the target section)
  → IF node (new hash matches stored hash?)
      → Match: Google Sheets log (timestamp only, no alert)
      → No match: OpenAI node (summarize the change in 2-3 sentences)
               → Slack or Email alert
               → Google Sheets (update baseline hash + timestamp)

That's it. The n8n-nodes-base.httpRequest v4.2 node fetches raw HTML or JSON depending on how the target site serves data. A Code node (n8n-nodes-base.code v2, parameter jsCode) normalizes the content and computes a SHA-256 hash. The IF node compares that hash against the value stored in a Google Sheets row from the previous run.

One thing that trips up first-time builders: the HTTP Request node returns full page HTML including navigation, cookie banners, and analytics scripts. Don't hash the whole page. Extract only the section that matters (the pricing div, the hero copy, the product grid) before hashing. Otherwise every cookie consent update fires a false alert.

Step-by-Step: From Trigger to Alert

1. Collect Competitor Data

A Schedule Trigger (n8n-nodes-base.scheduleTrigger v1.2) kicks the workflow off on a configurable cadence. For price monitoring, daily at 7:00 AM UTC works well. For landing page content, every 4 hours catches most changes without hammering the target server.

The HTTP Request node fetches the competitor page. Set Response Format to "String" for HTML pages. For sites that expose pricing through a JSON API, switch to "JSON" and parse the response structure in the Code node instead.

2. Compare Against a Baseline

The Code node normalizes the extracted content. For HTML, strip script and style tags and collapse whitespace before computing the hash:

const crypto = require('crypto');
const rawHtml = $input.first().json.data;
const cleaned = rawHtml
  .replace(/<script[\s\S]*?<\/script>/gi, '')
  .replace(/<style[\s\S]*?<\/style>/gi, '')
  .replace(/\s+/g, ' ').trim();
const hash = crypto.createHash('sha256').update(cleaned).digest('hex');
return [{ json: { hash, cleaned } }];

The previous hash lives in a Google Sheets row (one per competitor URL). There's no stored hash on the first run, so the Code node should handle a null baseline gracefully. Either skip the comparison entirely and treat the first run as a seed, or store the initial hash and skip the alert.

3. Detect Meaningful Changes

A raw hash difference tells you something changed. It doesn't tell you what. An OpenAI call earns its place here. Feed the previous and new content into the @n8n/n8n-nodes-langchain.openAi v2.1 node with a prompt like:

Old content: {previous_text}
New content: {new_text}

Identify what changed. Prices, product names, feature claims, removed sections, new CTAs.
Return a 2-3 sentence summary.

The response lands at $json.output[0].content[0].text. Not at .choices[0].message.content. That path belongs to the older n8n-nodes-base.openAi node, and it breaks silently when copied from 2023 tutorials. Worth memorizing which node you're using before the workflow runs in production.

4. Route Alerts to the Right Team

The AI summary goes to Slack, email, or both depending on the change type. A Switch node routes price changes to the sales channel and content changes to marketing. Doesn't need to be complicated — two branches handle most real-world scenarios.

5. Log Everything, Not Just Alerts

Alert-only workflows are a trap. The alert fires, someone reads it, and 3 months later leadership asks when competitor X lowered their price. Nobody knows, because alerts get dismissed and forgotten. Every run should update the Google Sheets row: new hash, timestamp, change summary, and whether an alert fired. After 90 days you'll have a full changelog of every competitor update, which is more durable than any notification.

You can't retroactively reconstruct what changed when, but if you've been logging every baseline update, pulling a competitor's pricing history takes seconds.

Three Monitoring Patterns That Work

Pattern 1: Price Delta Detection

Instead of hashing the full page, use a regex in the Code node to extract the price figure directly. The workflow then computes the numeric delta between the current price and the stored price. The IF node alerts only when the change exceeds a configurable threshold — for most B2B SaaS products, 5% is a meaningful signal; below that is rounding noise.

The Competitor Price Intelligence template handles this end-to-end. It reads a product catalog from Google Sheets (one row per competitor URL, your current price in an adjacent column), fetches each page on a daily schedule, extracts prices using per-product patterns, computes deltas, logs every check to a history sheet, and emails an AI-drafted response recommendation for any change above your threshold. Setup takes roughly 10 minutes.

Pattern 2: Full-Page Hash Monitoring

The general-purpose variant. Works on any URL: landing pages, documentation indexes, careers pages, blog home pages. Normalize, hash, compare, alert, summarize. Done.

It fires on any content change, including irrelevant ones like A/B test variants and rotating testimonials. In practice, restricting the hash target to pricing sections and hero copy keeps the false-positive rate low. Hashing the full page is useful for catching stealth changes (like a terms-of-service update buried in the footer) but it's noisy if it's your only monitoring layer.

Pattern 3: Market Signal Tracking

This pattern doesn't watch specific competitor URLs. It monitors communities for what the market is discussing: frameworks gaining traction, recurring complaints about incumbent tools, feature requests appearing across multiple threads in the same week.

The Market Trend Analyzer template runs this weekly. It pulls trending discussions from Hacker News and Reddit, scores them by engagement and recency, and uses OpenAI to surface emerging niches, market gaps, and product opportunities. Output is a structured email report plus a running Google Sheets log. You won't catch a competitor's pricing change with this one, but you will catch the conversation that precedes it.

n8n Nodes You'll Use Most

Getting Started with n8n Competitor Monitoring

1. Create a Google Sheets tab with one row per competitor URL. Add columns for: URL, stored hash, last checked timestamp, and your stored price if you're doing price delta tracking.
2. Add a Schedule Trigger. Daily for prices, every 4 hours for landing page content, weekly for market signal aggregation.
3. Use an HTTP Request node (Response Format: String) pointed at each URL. Loop over the Sheets rows using a SplitInBatches node at batch size 1.
4. Add a Code node to normalize the target section and compute the hash. Don't hash the full page — extract the relevant div or JSON key first.
5. Compare the new hash to the stored hash with an IF node. On a match, log the timestamp and stop. On a mismatch, call the OpenAI node with the old and new content to get a change summary.
6. Route the summary to Slack or email via a Switch node, then update the Google Sheets row with the new baseline hash and timestamp.

For price tracking, the Competitor Price Intelligence template is the fastest starting point. It handles price extraction, delta thresholds, history logging, and the AI recommendation step out of the box, and it reads its configuration from a Google Sheets catalog so you can add or remove competitors without touching the workflow.

Competitor intelligence workflows sit naturally alongside the analytics pipelines covered in n8n analytics automation and the scheduled reporting patterns in n8n data reporting automation. Both follow the same collect-process-report loop, applied to internal business metrics rather than external competitive signals.

For use cases that need to react to events as they happen rather than polling on a schedule, the n8n webhook automation guide covers inbound event-driven patterns using the Webhook node instead of the Schedule Trigger.