Competitor Monitor - SaaS Pricing, Changelog & Messaging
Ask your AI what your competitors changed since you last looked.
Competitor monitor for SaaS pricing pages, changelogs and homepages, only what changed since your last run: a price that went up, a plan that appeared or vanished, a new release, a rewritten headline. Each change comes back as a typed signal with its before and after, ready for a brief or a Slack alert.
Two things to know first. The first run only records a baseline, so changes start on the second. And pages are read by rules, so a page that shows a different price on different loads can read as a change that never happened, and is billed as one.
| Input | Competitor names with their pricing, changelog, homepage and docs URLs |
| Output | One row per page that is new, changed or failed, with typed signals and every field that moved, plus one brief row per run |
| Ceiling | No page cap: every URL you list is checked, within the run's time limit. A page it had not reached when the limit came is left for the next run and not charged, and the run's status says so |
| Speed | A few seconds a page, and 5 to 35 seconds for a page that only appears after its scripts run |
| Account needed | None on the sites you watch. Pages behind a login cannot be watched |
What SaaS Competitor Monitor does
It reads up to four pages for each competitor:
| Page | What it reads |
|---|---|
Pricing (pricingUrl) | Plan names, prices, buttons and features, and plans added or removed |
Changelog (changelogUrl) | Release entries |
Positioning (homepageUrl) | The main headline, the hero text and the primary button |
Integrations (docsUrl) | New integrations named on the page |
Every page is compared with the copy saved on your last run. That copy lives in a key-value store called saas-competitor-change-monitor-state, in your own Apify account, one record per competitor and page. Records are keyed by the competitor's name, so two tasks using the same name share one history, and renaming a competitor starts its history again.
A page that cannot be read comes back failed, is not charged, and the last good copy stays the baseline. Pages that only fill in after scripts run are drawn in a browser, which waits until the text stops growing. A page still drawing after 30 seconds fails, unbilled.
Each signal carries a "why it matters" line. With Generate AI insights on, which is the default, a language model writes that line for every changed page and the signal says ai_written: true. Switch it off and built-in rules write it instead, for free.
When page reading is improved, a page saved by the older reader shows as new once, so a better reading is never billed as a change.
What data you get from each page check
| What you get | Field |
|---|---|
| Which competitor and which page | target_key, competitor, page_type, url |
| Whether the page is new, changed, unchanged or failed | status, sync_status |
| The typed changes, each with a before, an after and a why-it-matters line | signals |
| Whether a model or the rules wrote that line | signals[].ai_written |
| Every field that moved, by path | change_records |
| On the brief row: how many signals the run found, and a link to the HTML brief | signal_count, brief_url |
What it does not do
- No pages behind a login. A page that answers with an error or a holding screen instead of content comes back
failedtoo. - No screenshots or visual diff. It compares the text and structure it reads.
- No perfect reading of pricing pages. Plans are found by rules. Scored on 40 real pricing pages, it found 135 of 144 plans. It can mistake a menu item or a calculator for a plan, miss a free plan shown only as the word "Free", and read only part of a tabbed plan layout.
- No archive. Only the latest good copy of each page is kept. The dataset of each run holds what changed on that run.
- The model does not find changes. The rules do. The model only writes the "why it matters" line on what they found.
- It is not an official tool of any platform or company named on this page. Dami's Studio is independent and is not affiliated with or endorsed by any of them.
How it works
- 1Open it on Apify
The Open on Apify button takes you there. Nothing to install.
- 2Set the inputs
The form opens with an example in Competitors. Put in your own and check the other settings.
- 3Click Run
It runs on Apify's servers, on your own Apify account.
- 4Export the results
Download them from the run, or read them over Apify's API.
Pricing
$0.01 per page
| You are charged for | When | Price |
|---|---|---|
| Page | A page was checked | $0.01 |
| Weekly brief | A weekly brief was generated | $0.30 |
| AI signal | An AI signal was generated | $0.035 |
| Change | A change was detected | $0.015 |
Live price on Apify's Free plan, read on 5 November 2026. Paid plans pay a little less. You are billed on your own Apify account. The full price list is on the Apify page.
Use it from your AI chat
Add Apify's connector to your AI chat once (setup steps), then paste this:
Use the Competitor Monitor (dami_studio/saas-competitor-change-monitor) to watch a competitor's pricing page and tell me what changed since my last run, and return one row per page that is new, changed or failed, with typed signals and every field that moved, plus one brief row per run. Ask me for the page's address first.Some apps ask for a server address instead. This one loads just this tool:
https://mcp.apify.com?tools=dami_studio/saas-competitor-change-monitorEvery run your AI chat starts goes on your own Apify account, at the prices on this tool's Apify page.
Inputs
| Field | What it does | Type |
|---|---|---|
competitors | The competitors to monitor. For each, provide a name and the URLs you want watched. Leave a URL empty to skip that page type for that competitor. | array |
watch | Which page types to monitor. 'pricing' tracks tiers/prices/CTAs/features, 'changelog' tracks release entries, 'positioning' tracks homepage hero & CTA, 'integrations' scans docs/changelog for new integrations. | array |
weeklyBrief | Produce a readable HTML/Markdown brief summarizing every competitor move this run, stored in the Key-Value Store and linked in the dataset. | boolean |
onlyNewSinceLastRun | Emit only the deltas (new/changed targets) instead of a full re-dump every run. This is what makes scheduled runs cheap and useful. | boolean |
generateAiSignals | Use a small LLM to sharpen the 'why it matters' analysis on each detected change. Runs ONLY on changed pages (never on unchanged ones). | boolean |
webhookUrl | Slack, Discord, or generic webhook to receive a compact summary of new signals. Slack/Discord formatting is auto-detected. | string |
The full input form is on the Apify page.
Questions people ask
How much does Competitor Monitor cost?
$0.01 per page on Apify's Free plan. Paid plans pay a little less. It is billed on your own Apify account.
Can I run Competitor Monitor from my AI chat?
Yes, from any app that supports MCP connectors. Add Apify's connector (https://mcp.apify.com/), sign in with your Apify account, and ask for dami_studio/saas-competitor-change-monitor. The steps are on the Use with AI page. Each run goes on your own Apify account, at the prices on its Apify page.
Do I need to write code to use Competitor Monitor?
No. Open it on Apify, fill in the form, click Run and download the results.