Competitor monitoring API that tells your code what a competitor just changed.
A competitor monitoring API watches competitor web pages on a schedule and reports what changed on them as structured data. Verid takes the pages your rivals actually move, pricing, plan tiers, positioning copy, changelogs and hiring, cuts each one into the fields you named with CSS, XPath, regex or an LLM prompt, compares them against the last check, and fires an HMAC-signed webhook when the rule you wrote is true. Down to every five minutes, across up to 1,500 pages on the Scale plan.
It is competitive intelligence as an event rather than a digest. A price cut arrives as entry_price 49 to 39, which a repricing service can act on. It does not arrive as a screenshot for somebody to interpret on Monday.
- 5 monitors free, no card
- 5 min fastest check on Scale
- 9 alert rules
- one POST to start
- entry_price
- 49→39
- Δ -20%
- plan_names
- 3 tiers→4 tiers
- new tier
- seat_price
- 12→12
- unchanged
Straight answers
Competitor monitoring API at a glance
Twelve answers with no adjectives in them. Every number is read from the shipping product rather than from a sales sheet, and the ones that differ by plan say which plan. If you are weighing this against a competitive intelligence platform, rows one and two are the ones that decide it, and the comparison table takes it row by row.
- What it ischange detection
- Scheduled change detection pointed at competitor pages, with the field level diff and the alert as the product.
- What it is notno battlecards
- Not a competitive intelligence suite. No analyst digest, no battlecard editor, no win-loss module, and no dashboard anybody is expected to open on a Monday.
- Inputurl + fields
- A public competitor URL you choose, plus one selector for each element you want to follow over time.
- Outputdiff webhook
- A JSON webhook holding the previous object, the current one, and the list of field names that moved. Full shape in the REST API reference.
- Extraction methods6 methods
- CSS, XPath, regex, JSONPath, whole page text, or an LLM prompt with a response schema. One method per monitor, so a page read two ways is two monitors on the same URL.
- Alert rules9 predicates
- Any field, one field, four numeric threshold rules, exact value, regex, and a composite of any of those. All nine are documented under predicates.
- Price moves4 threshold rules
- Extract a price as a number and a threshold rule fires on the move itself, up or down, by percent or by absolute amount, so currency rounding wakes nobody.
- Fastest check5 min on Scale
- Set per monitor in seconds and floored by your plan: daily on Free, every two hours on Lite, hourly on Starter, 15 minutes on Pro. Every floor is on the pricing page.
- Scale unit1,500 pages
- One monitor per watched page and extraction method, not per competitor. Five on the permanent Free plan, 250 on Pro, 1,500 on Scale, which is roughly 250 competitors covered six pages deep.
- Where alerts land4 channels
- Signed webhook, Slack, Discord or email. Endpoints per monitor are capped by plan, from one on Free to 25 on Scale, so competitor A can reach a different channel to competitor B. See notifications.
- Delivery guarantee6 attempts
- Six attempts spread across roughly four hours, each signed with HMAC-SHA256, then the dead letter queue for a manual replay.
- What you bringyour own list
- The competitive set and the URLs. There is no competitor discovery here, and scraping and change detection answer different questions.
The competitive surface
Which competitor pages to monitor, and what each one tells you
Competitor website monitoring goes wrong at the first step, when somebody points one monitor at a homepage and waits. A competitor is not a page, it is six of them, and they move at completely different speeds: a pricing page can change twice in a quarter and a changelog twice in a week. Below is the manifest one competitor actually costs, then every page type worth watching with the fields and the interval that suit it.
Nineteen fields across six pages. One competitor, with no blind spot left in price, packaging, positioning, launches, hiring or proof.
The interval is a statement about the page, not about your budget
Every row in that manifest carries its own interval because the alternative is choosing one cadence for a competitor and being wrong about five of their six pages. An hourly check on a customer wall is waste. A weekly check on a campaign landing page means you read about the promotion after it ended. Getting this right is most of the difference between a monitoring setup that survives and one that gets muted.
It is also what makes the cost predictable. One monitor is one page read one way, so the bill is a page count you can work out on paper before you create anything, and scaling to many competitor pages is arithmetic rather than a negotiation.
{ "url": "…/pricing", "schedule_interval_seconds": 3600, "extract_config": { … } }Nine pages worth a monitor, and the signal each one carries
| Page | What moves there | Fields | Interval | What the change tells you |
|---|---|---|---|---|
| Pricing page | Tier prices, per-seat prices, the annual discount, the number of plans. | entry_price, seat_price, plan_names, annual_discount | Hourly | A repricing, a new tier, or a repackaging you are about to be compared against. |
| Plan comparison table | Which features sit on which tier, and which ones moved up a tier. | starter_features, enterprise_only | Daily | What they now consider premium, which is the clearest read on their margin pressure. |
| Homepage hero | The headline, the subhead, the first three feature bullets. | hero_headline, hero_sub, bullets | Every 6 hours | A repositioning, usually weeks before there is a press release to read about it. |
| Changelog or release notes | The newest entry title and its date. | latest_release, release_date | Hourly | The launch, on the day it ships rather than the month it gets a blog post. |
| Docs index or API reference | New pages in the navigation, new endpoints in the reference. | nav_titles, endpoint_count | Daily | A capability arriving before marketing has decided how to sell it. |
| Careers board | Open roles, team names, locations, the count itself. | role_titles, role_count | Daily | The team being staffed for their next bet, which is the earliest signal on this list. |
| Customer wall and case studies | Logos, named accounts, the newest study title. | logo_count, newest_case_study | Weekly | The segment they are winning in, and the account they are proud enough to name. |
| Campaign and paid landing pages | Offer copy, promo codes, discount percentages, the trial length. | offer_headline, discount_pct, trial_days | Hourly while a campaign runs | The promotion while it is still running, which is the only time it is actionable. |
| Status and trust pages | Open incidents, subprocessors, certifications, uptime claims. | open_incidents, certifications | Hourly, or weekly for trust | A reliability argument you can make honestly, and a compliance move you can match. |
Field names in the middle column are suggestions. A field is whatever you call it, and the diff reports the names you chose, which is why a competitor alert can read like your own vocabulary rather than a vendor schema. Four of these nine pages have a worked walkthrough of their own: tech stack changes on their markup, job listings for keywords on the careers board, status page incidents and terms of service and policy drift.
What a competitive set costs in monitors
One competitor, properly covered
Six pages is the depth at which a competitive set stops having blind spots: price, packaging, positioning, launches, hiring and proof. That is six monitors, which fits inside the permanent Free plan only if you are watching one company.
A real competitive set
Five competitors at six pages each is 30 monitors, which is Lite at 25 if you trim to five pages and Starter at 50 with room to grow. Most teams run pricing and changelog on every competitor, and the other four pages on the two that actually show up in deals.
A category, not a shortlist
Twenty five companies six pages deep is 150 monitors, which is Pro at 250. The cost driver is the page count rather than the check volume, so the arithmetic is something you can do before you sign up rather than a quote you have to request.
see alsocatching pages before they launchad and landing copy changespricing pages into webhooks
The loop
How competitor website monitoring runs, from URL to webhook
Five things happen on every check, in this order, whether the monitor runs once a day or every five minutes. Each stage hands the next one a smaller object than it was given, which is why the thing that finally reaches you is one sentence rather than a web page. Four of the five you configure once and never think about again. The fifth is the only one you ever hear about.
Name the page, not the company
A competitor is not a monitor. Their pricing page is, and so is their changelog, their homepage and their careers board. Each becomes one monitor with its own URL and its own interval, because those four pages move at wildly different speeds. Pages assembled in JavaScript get fetch_mode set to browser and load in real Chrome instead of an HTTP client.
takesa competitor and a question
url + intervalgivesone monitor per URLCut the page into fields you named
Point a selector at each part that carries meaning and it becomes a key in a flat JSON object: the entry price, the per-seat price, the plan names, the hero headline, the newest release title. There are six methods to reach them and a monitor carries exactly one of them, so a page you want to read two ways is two monitors on the same URL. The field names are yours either way, so the alert you eventually read is written in your vocabulary rather than a vendor schema.
takesthe rendered page
extract_configgivesan object with your keysCompare it against the last check
The new object is compared key by key with the object stored for the previous run of this monitor. What comes out is the list of field names that moved plus the before and after value of each, which is a far smaller thing than two web pages and the reason a competitor alert is readable in a Slack line.
takesan object with your keys
fields_changedgivesthe field level diffGate it on the rule you wrote
One predicate decides whether the change deserves anybody. Any tracked field moving, one named field only, a price falling by more than 5 percent, a value going empty, a regex hit, or a composite of those joined with AND or OR. A run that fails the predicate is still recorded in full, it just does not deliver.
takesthe field level diff
diff_predicategivesone booleanDeliver it where the decision happens
A qualifying change leaves as an HMAC-signed POST to your endpoint, and to Slack, Discord or email at the same time if you want it there too. The payload carries the previous value, the new value and the changed field names, which is enough for a handler to reprice, to write a CRM note, or to append a warehouse row without fetching anything.
takesone boolean
deliveriesgivesa signed webhook, or a quiet run
Two details in stage three are worth knowing before you trust an alert. The comparison is against the previous run of the same monitor and nothing else, so a monitor created this morning has no opinion about what a competitor did last week, and your first check is your baseline. And a field whose selector stops matching extracts an empty string rather than an error, which is a change like any other. The anatomy of a monitor covers every part of that object, and the playground runs a selector against a live competitor page with no account, which is the fastest way to find out whether their markup is going to cooperate.
Extraction
A competitor pricing page, cut into fields you named
A monitor does not store a copy of a competitor pricing page and it does not store a price. It stores a flat JSON object whose keys are the names you chose, and the diff you receive is a list of those names. Six fields on one page below, with the method that reaches each. The distinction that matters most is on the right: a price extracted as a number can be compared with a threshold, and the same price extracted as the string dollar forty nine cannot.
An extract_config names a single method and then a set of fields under it, so the six fields below are four monitors pointed at the same URL: the three CSS fields together, the regex number, the XPath line, and the prompt. Most pages need only one of the four. Plan the extra ones into your monitor count when a page genuinely needs two ways of being read.
- "hero_headline":"Invoicing that closes itself"css
h1 - "annual_discount":"20"regex
Save (\d+)% - "plan_names":["Starter", "Team", "Business"]css
.tier__name - "entry_price":"39"css
.tier--starter .price - "seat_price":"$12 per seat"xpath
//li[contains(.,"per seat")] - "enterprise_gate":"sso, audit log, sla"prompt
List the features marked Enterprise only
Values are illustrative of one run, in the shape each extractor really returns. The keys are yours, and the diff names them.
Extract prices as numbers, or the thresholds are useless
Four of the nine alert rules are numeric: percentage and absolute, in both directions. All four need a field that parses as a number, which means the selector has to land on 49 rather than on From $49 per month billed annually. Where the markup will not give you a clean number, a regex extraction pulls one out of the sentence, and that single decision is what separates a competitor price monitor you can automate from one that emails a person.
String fields get the other five rules
A headline, a release title and a set of enterprise-only features are strings, and a selector matching several nodes gives you an array of them, which is what a list of tier names is. Both are watched with field_changes, a regex match, or an exact value comparison against the empty string when what you want to know is that something disappeared. A composite rule then joins the two families, which is how one monitor can say: wake me on a 5 percent price cut or a new tier, whichever lands first.
What each field is actually good for
hero_headlinestringThe clearest single statement of what a competitor believes they sell. When this string moves, the positioning moved with it.
- via
- css
- rule
- field_changes
annual_discountnumberA number pulled out of a sentence. Regex is how a percentage buried in marketing copy becomes something a threshold rule can compare.
- via
- regex
- rule
- field_decreases_by_absolute
plan_namesstring[]A selector matching several nodes returns one string per node, so this field is an array and a tier appearing, disappearing or being renamed is a diff on it.
- via
- css
- rule
- field_changes
entry_pricenumberThe field most teams build the whole monitor for. A CSS selector returns the text of the node it lands on, so this only parses as a number when that node holds the digits alone. Where the currency symbol sits inside it, reach the number with regex instead.
- via
- css
- rule
- field_decreases_by_percent
seat_pricestringXPath finds the line by the text inside it, which is the right tool when the markup has no class worth trusting. It returns the whole line, so this one tells you the per-seat price moved. For a threshold on the number itself, pull it out with regex.
- via
- xpath
- rule
- field_changes
enterprise_gatestringA judgement about the page rather than a node in it. A model reads the rendered tiers and returns JSON, so a feature moving up a tier is a diff. Send a response schema with the prompt, because the schema is what fixes the key names from run to run.
- via
- prompt
- rule
- field_changes
Five of the six use a selector, and which language you reach for is mostly about how stable their markup is: the CSS selector guide covers the common case, and XPath is what you want when the only reliable anchor is the text of a neighbouring element, which on a pricing page it often is. The sixth field uses prompt extraction: you describe the shape you want and a model reads the rendered page and returns it, which is the method for a judgement about the page rather than a node in it. The LLM call budget on your plan is what bounds that, from 50 calls a month on Free to 25,000 on Scale.
see alsothe worked price tracking monitora JSON field on their API
Automation
From one change event to the system that acts on it
A competitor change nobody acts on is trivia. Automated competitor monitoring is worth paying for at exactly the point where the event reaches something that can respond: a repricing service, an open deal, a warehouse table, or the one channel a team still reads. Because delivery is a signed POST rather than a digest, all four can happen on the same run, and the same payload feeds every one of them.
Reprice before the week is out
The handler reads fields_changed, sees entry_price, and compares the new number against your own list price. If the gap crosses whatever your pricing team decided is intolerable, it opens a pull request against the price config rather than sending a human a screenshot. The whole exchange is two numbers, which is why it can be automated at all.
- field
- entry_price
- rule
- field_decreases_by_percent, 5
Put it on the deal, not in a channel
The same payload can look up open opportunities tagged with that competitor and append a note carrying the before and after value. A rep in a live deal learns the discount changed from the record they already have open, which is the difference between competitive intelligence and competitive trivia.
- field
- annual_discount
- rule
- field_changes
Append a row, keep the series
Every delivery is one row: monitor name, field, before, after, fired_at. Written to your warehouse it becomes a price and positioning history you own, queryable next quarter, with no retention cliff and no export button. Verid keeps its own run history too, from 14 days on Free to 24 months on Scale.
- field
- any
- rule
- any_field_changes
Tell the humans, once
A Slack or Discord line for the changes a person genuinely has to judge: a repositioned headline, a new tier, a launch. Because delivery is per monitor, the pricing monitors can post to the revenue channel while the changelog monitors post to the product one, and neither has to filter the other.
- field
- hero_headline
- rule
- field_changes
The four places a competitor change can land
Deliveries are configured per monitor, which is what lets the pricing monitors reach a revenue channel while the changelog monitors reach a product one. The cap is one endpoint per monitor on Free and 25 on Scale, and every channel receives the same diff.
| Channel | Best for | What it carries | Worth knowing |
|---|---|---|---|
| Signed webhook | Anything that has to act: repricing, CRM writes, warehouse appends, an agent. | The full payload, HMAC-SHA256 signed, retried six times. | Custom request headers are allowed, up to 20 per monitor. |
| Slack | The changes a person has to judge rather than a service has to process. | Monitor name, URL, the changed fields and their before and after values. | One incoming webhook URL per delivery, so channels split per monitor. |
| Discord | The same job as Slack, for teams and communities that live there instead. | The same summary, formatted for a Discord webhook. | Identical configuration shape, so switching is a one-line change. |
| Low-frequency pages and stakeholders who will never open a dashboard. | A readable summary of the same diff. | One address per delivery. Best on daily and weekly monitors. |
There is no competitor dashboard to live in
You get a place to manage monitors and read run history, and that is the extent of it. The dashboard your team actually reads is the one you already have: a Slack channel, a CRM field, a BI chart over your own table. That is a deliberate trade rather than a missing feature, and it is the wrong trade for you if a ready-made competitive view is what you are buying. It is the right one if the events need to reach code, which is also why an agent can consume the same feed without re-reading a page.
What a handler should do on arrival
Verify the signature first, then switch on fields_changed rather than diffing the two objects yourself, then treat the delivery id as an idempotency key so a retry cannot write the same CRM note twice. Return a 2xx quickly and do the slow work on a queue, because a handler that takes thirty seconds turns a retry ladder into a duplicate storm. If you would rather not write a handler at all, n8n, Zapier and Make all take the webhook directly.
see alsoalerts into Slackseven competitive intelligence workflowsSaaS pricing at scale
Noise control
Nine alert rules, so the competitor channel stays worth reading
Every competitor monitoring setup dies the same way: it fires on a footer year, then on a rotated testimonial, then on nothing anybody can name, and by week three the channel is muted. The rule is what prevents that, and it is the part of the configuration that carries your actual judgement about what matters. All nine below are real predicate types, and any of them can be combined with AND or OR.
| Rule | Fires when | The competitor question it answers |
|---|---|---|
| any_field_changes | Any tracked field on the monitor moved. | Did anything at all change on this page? The right rule for a first monitor. |
| field_changes | One named field moved, and the others are ignored. | Did the positioning headline get rewritten, whatever else the page did? |
| field_decreases_by_percent | A numeric field fell by more than your percentage. | Did they undercut us by enough to matter, ignoring currency rounding? |
| field_increases_by_percent | A numeric field rose by more than your percentage. | Did they raise prices, which is the moment your own increase gets easier? |
| field_decreases_by_absolute | A numeric field fell by at least your amount. | Did the discount drop by five points or more in real terms? |
| field_increases_by_absolute | A numeric field rose by at least your amount. | Did the open role count jump, which is a team being staffed? |
| field_matches_regex | The new value of a field matches your pattern. | Did the word enterprise, or a competitor name, appear in their copy? |
| field_equals | The new value of a field is exactly yours, an empty string included. | Did the tier we track disappear from the page entirely? |
| composite | Several of the above, joined with AND or OR. | Wake me on a 5 percent price cut or a new tier, whichever happens first. |
Two details worth knowing before you write one. A rule is only reached on a run where at least one tracked field actually moved, so a quiet check never delivers whatever the rule says. And the two rules that read a value rather than a movement, field_matches_regex and field_equals, test the new value on such a run: they fire while the value still matches, not only on the run it started matching.
Extract less than you can
The temptation is to select the whole pricing table. The result is an alert every time a footer year or a testimonial rotates. Four named fields beat one big blob, because the diff then names the thing that moved instead of telling you the page is different.
Put a number on the threshold
A price field with a bare field_changes rule fires on a currency rounding. The same field with a 5 percent decrease rule fires when a decision was made. The threshold is where your judgement about what matters actually lives, and it is the single biggest lever on alert volume.
Match the interval to the page
A pricing page hourly and a careers board daily is a normal split; both hourly is how a channel gets muted in week three. If a page has changed twice in a year, a daily check is not a compromise, it is the correct setting.
The contract
One request in, one signed diff out
A competitor monitor is an ordinary monitor with a competitor URL on it, so the same POST that creates anything else creates this. The request on the left checks a competitor pricing page hourly in a real browser, tracks four fields, and fires on a real price cut or a packaging change while staying silent on everything else. The payload on the right is what your endpoint receives on the run where two of those four fields moved.
curl -X POST https://api.verid.dev/v1/monitors \
-H "Authorization: Bearer vrd_your_api_key" \
-H "Content-Type: application/json" \
-d '{
"name": "Competitor C / pricing and packaging",
"url": "https://competitor-c.example/pricing",
"fetch_mode": "browser",
"schedule_interval_seconds": 3600,
"extract_config": {
"method": "css",
"fields": {
"entry_price": ".tier--starter .price",
"seat_price": ".tier--team .per-seat",
"plan_names": ".tier__name",
"hero_headline": "h1"
}
},
"diff_predicate": {
"type": "composite",
"operator": "OR",
"conditions": [
{ "type": "field_decreases_by_percent", "field": "entry_price", "threshold": 5 },
{ "type": "field_changes", "field": "plan_names" },
{ "type": "field_changes", "field": "hero_headline" }
]
},
"deliveries": [
{ "type": "webhook", "url": "https://api.yourapp.com/hooks/competitors" },
{ "type": "slack", "webhookUrl": "https://hooks.slack.com/services/..." }
]
}'{
"id": "7c9f2a10-4d6b-4f88-9b02-1e5a83d7c410",
"version": "2026-05-01",
"monitor_id": "4b19e6c2-8f31-4a77-b0d5-2c6e9a41f883",
"run_id": "08cd5f7a-1b94-4e26-8a3f-5d70c2b6e915",
"fired_at": "2026-08-12T14:03:11.802Z",
"diff": {
"fields_changed": ["entry_price", "plan_names"],
"before": {
"entry_price": "49",
"seat_price": "$12 per seat",
"plan_names": ["Starter", "Team", "Business"],
"hero_headline": "Invoicing that closes itself"
},
"after": {
"entry_price": "39",
"seat_price": "$12 per seat",
"plan_names": ["Starter", "Team", "Business", "Scale"],
"hero_headline": "Invoicing that closes itself"
}
},
"monitor": {
"name": "Competitor C / pricing and packaging",
"url": "https://competitor-c.example/pricing"
}
}Read the diff, not the object. fields_changed is the list of keys that moved, so a handler is a switch on strings rather than a comparison of two payloads. Here it is entry_price and plan_names, and hero_headline is absent from that list, which is how you know the price moved without the positioning moving with it.
Verify before you trust it. The signature is an HMAC-SHA256 over the timestamp and the raw request body, so a replayed or edited payload fails verification. Fetch the plaintext secret once from GET /v1/monitors/{id}/signing-secret and keep it out of your logs.
Failures are not dropped. A delivery is attempted six times across roughly four hours: immediately, then after 5, 15 and 30 minutes, then 1 hour and 2 hours, before it is parked for a manual replay. The rest of the operational detail is in webhook best practices and the webhooks documentation.
Honest comparison
Competitor monitoring API compared to the four things it is not
Five categories that all claim to tell you what a competitor is doing, answering completely different questions underneath. Read down the row that matters to you rather than across the column with the most ticks, because on four of these rows something else is the better answer and you should know that before you wire anything in. If you are weighing building the loop yourself, the build versus buy arithmetic is a sixth column.
| Criterion | Verid | CI platforms | Visual monitors | Price trackers | Keyword alerts |
|---|---|---|---|---|---|
| What you receive | A signed JSON event naming the fields that moved | Curated battlecards, digests and enablement content | A screenshot pair and a change summary | A price table for products you mapped | Links to pages that mention a term |
| Coverage | Any public URL you name, any industry | Curated sources plus their own crawler | Any public URL | Retail and marketplace product pages | Whatever the index picked up |
| Price change detection | Numeric fields with percent and absolute thresholds | Usually a narrative mention in a digest | Only if the change moved pixels | Yes, and it is the whole product | No |
| Positioning and copy drift | A string field per headline or bullet | Yes, summarised by an analyst or a model | Visible in the image, not as data | No | Only if the wording matches your term |
| Feeds your own systems | Signed webhooks into any endpoint, up to 25 per monitor | CRM integrations, usually on higher tiers | Basic webhooks or a Zapier step | An export or a partner API | Email or RSS only |
| Time to know | Your check interval, down to 5 minutes | A daily or weekly digest cycle | Their check interval, often daily on cheap plans | Usually daily | Whenever the crawler notices |
| Who operates it | An engineer or a technical marketer, once | A product marketing owner, continuously | Anyone | A pricing or ecommerce analyst | Anyone |
| Where the history lives | Your warehouse, plus Verid run history | The vendor platform | The vendor account | The vendor account | Your inbox |
| Entry cost | Free for 5 monitors, then $9 a month | Annual contracts, often five figures | Roughly $10 to $110 a month | Roughly $50 to $500 a month | Free |
Costs in the last row are the published entry prices for each category as of August 2026, not quotes. The search side of a competitive set is a category of its own and lives on the SERP tracking API, which watches who is above you on a query and when that changed.
If you are already running one of these
You already pay for a CI platform
Keep it. Crayon, Klue and Kompyte are built for a product marketing function: they curate, they summarise, they produce the battlecard your sales team reads before a call, and none of that is on offer here. What they are weak at is a precise, structured event your code can act on within the hour. Run this underneath as the signal layer and let the platform keep doing the narrative, which is roughly the split the tools comparison lays out tool by tool.
You are using a visual change monitor
A screenshot diff tells you a region of the page is different. It cannot tell you that entry_price went from 49 to 39, which is the sentence a repricing service needs. The honest answer is that you want both, on the same URL, and the Visualping comparison goes through where each one wins. Verid does the pixels too: visual monitoring is a flag on the same monitor.
You are on Google Alerts and a spreadsheet
Alerts fire on mentions of a term, which means you learn about a competitor price change when somebody writes about it, not when it happens. A monitor on the page itself is the earlier signal, and the Google Alerts comparison covers that ground properly. If your set is retail rather than software, the pricing tools roundup is the better starting point.
Where it stops
What this competitor monitoring API does not do
Six places where this is the wrong tool, is weaker than the copy above would like, or stops on purpose. Two of them are behaviours you would otherwise discover on day three, which is the only reason to put a section like this on a page trying to sell you something.
It does not write your battlecards
Verid delivers change events, not curated narratives. Nobody here summarises the quarter, scores a competitor, or drafts the objection handling. If what you need is competitive intelligence written for you by a platform and a team, buy that instead, and expect the contract that comes with it.
Public pages only
If a signal has no public URL, this cannot see it. Gated demo flows, anything behind an interactive login, private communities, paid analyst reports, most ad libraries and most social feeds are all out of scope. Reviews, ads and social listening are genuinely better served by tools built for them.
You own the selector when they redesign
Competitors rebuild their pricing page, and a CSS selector that pointed at a class name goes with it. A field that stops matching extracts an empty string rather than raising an error, which is a change like any other: useful when the tier really did disappear, and worth checking in the run history when it was the markup that moved. Prompt extraction is the escape hatch, at the cost of up to one LLM call per check against your plan budget. A check whose page content has not moved is served from cache and costs nothing.
One event per change, not a weekly digest
Delivery is event by event. A Monday rollup is something your handler builds by buffering events, or something you approximate by pointing several low-frequency monitors at one email address. The predicates and the intervals are the tools for keeping the volume sane, and they are levers rather than a digest setting.
No competitor discovery and no market data
There is no traffic estimate, no share of voice, no funding feed and no list of companies you should be watching. You bring the competitive set. If you want the estimation layer, keep the research tool you already pay for and use this for movement between its refreshes, the way a price intelligence system is normally assembled.
You choose the targets responsibly
Watching a competitor pricing page is ordinary market research, and it is still your call to respect robots directives, terms of service and a check frequency that would not embarrass you in writing. The interval control exists precisely so a monitor can stay polite, and the legal ground is worth reading first.
Competitor monitoring questions
The fourteen things product, growth and pricing teams ask before they wire competitive signal into their stack, answered with the numbers the product enforces.
What is a competitor monitoring API?
A competitor monitoring API watches competitor web pages on a schedule and sends your code a structured event when something you defined changes. With Verid you name the page and the fields, for example each plan price and the homepage headline, gate the alert with a rule such as a 5 percent price drop, and every qualifying change arrives as an HMAC-signed JSON webhook carrying the previous value, the new value and the list of fields that moved.
What can I actually monitor on a competitor?
Anything on a public URL. The nine pages worth watching are the pricing page, the plan comparison table, the homepage hero, the changelog or release notes, the docs index, the careers board, the customer wall, campaign landing pages, and the status or trust page. Each becomes one monitor with its own fields, its own rule and its own interval, which is what lets a pricing page run hourly while a careers board runs daily.
How is this different from Crayon, Klue or Kompyte?
Those are competitive intelligence platforms built for product marketing: curated feeds, battlecards, enablement content, win-loss analysis and annual contracts. Verid is the raw signal layer underneath. You get a precise structured change event at a self-serve price and decide what to build on it, and there is no analyst, no battlecard editor and no narrative. Teams that need both usually run Verid as the detection layer and keep the platform for the narrative.
Is there a competitor monitoring dashboard?
There is a dashboard for managing monitors and reading run history, but it is not where the product happens and you are not expected to live in it. The output is a webhook, so the dashboard your team actually reads is whatever you build on your own data: a Slack channel, a CRM field, a warehouse table, a BI chart. That is a deliberate trade. If a ready-made competitive dashboard is what you want, a platform is the better purchase.
Can it track competitor prices?
Yes, and it is the most common use. Extract each price as a bare number, either with a CSS selector that lands on the node holding the digits or with a regex that pulls them out of the surrounding sentence, then gate the monitor with a threshold predicate such as field_decreases_by_percent at 5, so currency rounding and cosmetic edits stay silent. The webhook carries the old price, the new price and the field name, which is enough for a repricing service to act without fetching the page again.
How fast will I know a competitor changed something?
Detection lag is your check interval plus the time it takes to fetch and render the page. The interval is set per monitor in seconds and floored by your plan: once a day on Free, every two hours on Lite, hourly on Starter, every fifteen minutes on Pro and every five minutes on Scale. Pricing and campaign pages usually run at the floor while hiring and customer pages run daily or weekly.
How many monitors do I need for a real competitive set?
Roughly six pages per competitor covers price, packaging, positioning, launches, hiring and proof. Five competitors is therefore about 30 monitors, which fits the $19 Starter plan with room to spare, and twenty five companies six pages deep is 150 monitors, which is Pro at $49. Start with the two pages per competitor that would actually change a decision, then widen.
How do I keep the competitor channel from becoming noise?
Three levers, in order of effect. Extract only the fields that carry meaning rather than selecting a whole section. Put a number on the rule, so a price field fires on a 5 percent move rather than any move at all. Set an interval that matches how fast the page really changes. Teams that do all three still read the channel six months later, and teams that do none of them mute it in week three.
Will it catch a redesign or a new campaign creative?
Enable visual monitoring on the same monitor and every check also screenshots the page and pixel-diffs it inside the regions you chose, with its own percentage threshold. You get the design change as an image pair and the copy change as named fields, from one check on one URL, which is the pairing that explains both what moved and what it now says. Visual monitors carry their own plan cap, from one on Free to 500 on Scale, because every one of them renders a browser and stores images.
Can I send different competitors to different places?
Yes. Deliveries are configured per monitor, so competitor A can post into the revenue channel while competitor B goes to your own endpoint and into the warehouse. One monitor can hold up to 25 endpoints on the Scale plan, one on Free, and the four channel types are signed webhook, Slack, Discord and email.
Does it monitor competitor ads, social media or reviews?
Only where those live on a stable public page. A paid landing page behind an ad is an ordinary URL and monitors well, so offer copy, promo codes and trial lengths are all in scope. Ad libraries, social feeds and review platforms usually require a login or an API of their own, and a tool built for social listening or review monitoring will serve you better there.
Can it feed an AI agent or a data warehouse?
That is the intended shape. Because every change is a signed JSON POST rather than an email, the natural consumers are a handler that writes a warehouse row, a workflow in n8n, Zapier or Make, or an agent that needs to know a competitor price moved without re-reading the whole page. The payload names the changed fields, so a consumer switches on strings instead of comparing documents.
Is competitor monitoring legal?
Reading a competitor public web page is ordinary market research, and businesses have done it since long before it was automated. What matters is how you do it: respect robots directives and terms of service, keep the check frequency reasonable, take only what you need, and do not touch anything behind a login you were not given. Verid gives you per-monitor interval control precisely so a monitor can stay polite, and the choice of target remains yours.
Is there a free way to monitor competitors this way?
Yes, within honest limits. The permanent Free plan gives you five monitors checking once a day, with fourteen days of run history, one delivery endpoint each and no card required. That is one competitor covered five pages deep, or five competitors covered on pricing alone. Faster intervals and higher monitor counts start at $9 a month, and every predicate and extraction method is available on every plan.