CHANGE DETECTION API

You already collect the data. Nothing in your stack says what changed.

ChangeGraph is the detection layer, not the crawler. Send successive observations of the same subject (from your own crawler, a licensed feed or an internal system of record) and every material difference comes back as a typed event: the old value, the new value, the evidence it came from, and a confidence score you can reproduce by hand.

Get Free API Key See Example Event

Free tier: 25 monitored entities/month Paid from $299/month No card to run the demo

Live change detection Ready

Two observations of the same company. Edit either side.

Runs the same engine the paid endpoint uses. Nothing is stored and no key is needed.

Press “Detect changes” to call the live API.

The problem

You didn’t know something important changed.

Not because nobody was looking. Because looking is manual, inconsistent, and buried under thousands of changes that don’t matter.

You find out too late

Pricing gets rewritten, plans get repackaged, products ship and executives move long before anyone on your side notices. By the time it reaches you it isn’t news: it’s history, and the decisions it should have informed are already made.

Your team is manually watching

Someone is opening competitor pricing pages, docs, changelogs, release notes and announcements by hand. It costs hours a week, it is inconsistent between people, and it stops entirely the week that person is busy.

Most changes are noise

A page edit is not an event. Reworded copy, moved buttons and rotated footers bury the handful of material changes underneath thousands of raw diffs nobody can triage.

What late costs

Late awareness never arrives as a line item. It arrives as a lost deal.

Nothing invoices you for learning in May what changed in March. The cost lands somewhere else, on somebody else’s number, usually without the cause attached.

Sales
The discount is given away before you know why you needed it
A competitor repackages a plan and drops the entry price. Your reps meet the new number in the field, concede on price to hold the deal, and the reason surfaces weeks later in a lost-deal review.
Renewal
You renew against facts that stopped being true
A vendor you depend on changes its pricing, its leadership or its ownership. If that reaches you after the renewal is committed, you have already signed another term on terms you would have renegotiated.
Roadmap
The roadmap argument is settled by whoever checked most recently
A competitor enters a region, ships a product line or changes its stack. Without a dated record of what changed and when, the loudest opinion wins the quarter instead of the best evidence.

The solution

ChangeGraph turns changes into events.

Not a diff, and not an alert that says something moved: a typed record of what changed, from what to what, on what evidence, with a confidence score derived from the observation itself.

Monitored Detected Classified Evidence retained Structured event Into your workflow

01
Monitored

You register the entities you care about (a company, a product, a vendor, a site) and the change kinds you want. Filtering happens server-side, so you never receive the kinds you didn’t ask for.
02
Detected

Each new observation is diffed against the previous one for that entity. Only facts that actually differ survive; an identical value produces nothing at all, so an unchanged page stays silent.
03
Classified

Every surviving change is typed (pricing, hiring, product, technology, executive or expansion) with a direction: added, removed, increased, decreased or modified. That is what makes it routable instead of readable.
04
Evidence retained

Both source observations stay attached to the event: where each value was seen, and when. A claim can be checked rather than trusted, months after anyone remembers making it.
05
Structured event

You get JSON with a stable shape (subject, kind, direction, before, after, confidence, summary, evidence, detectedAt) so code can act on it without a human reading a diff first.
06
Into your workflow

Read events from the API, newest first, and route them wherever decisions already get made: an alert, a queue, a CRM field, a briefing, an agent.

Example event

This is what a material change looks like when it reaches your code.

One element of the events array returned by POST /v1/monitors/:id/snapshots: a competitor’s Pro plan moving from $49 to $59, detected against the previous observation of the same page.

{
  "id": "evt_snap_8c1f4e02-3d77-4a51-9b6e-0f2a7c5d1e93_plan.pro.monthly",
  "monitorId": "mon_5f1c0b2e-7a44-4c19-9d0e-2b8f6d3a1c55",
  "subject": "Acme Corp",
  "kind": "pricing",
  "direction": "increased",
  "factKey": "plan.pro.monthly",
  "before": "49",
  "after": "59",
  "confidence": 100,
  "summary": "Acme Corp: \"plan.pro.monthly\" increased from \"49\" to \"59\".",
  "evidence": [
    {
      "source": "https://acme.com/pricing",
      "observedAt": "2026-08-24T09:04:11.802Z",
      "factKey": "plan.pro.monthly",
      "before": "49",
      "after": null
    },
    {
      "source": "https://acme.com/pricing",
      "observedAt": "2026-08-31T09:04:09.517Z",
      "factKey": "plan.pro.monthly",
      "before": null,
      "after": "59"
    }
  ],
  "detectedAt": "2026-08-31T09:04:09.988Z"
}

Confidence is derived, not asserted

The 100 above is arithmetic: +40 because the fact key maps to a known kind, +30 because both sides parse as numbers, +20 because both observations share a source, +10 because the value changed rather than appeared. You can reproduce the score yourself.

Evidence on every event

The evidence array carries both observations: the source each value came from and the timestamp it was seen. That is what turns “we think they raised prices” into something you can put in front of a customer.

You supply the observations

ChangeGraph diffs what you send it, from your own crawler, a licensed feed or an internal system of record. No third-party data is resold, and nothing is scraped on your behalf.

This service is newly launched. We publish no uptime percentage, customer count, logo wall or certification claim until we have the operating history to support one.

How it works

Three calls from zero to a stream of typed events

Create a monitor
POST the subject you want watched and the change kinds you care about. That subject is the billable monitored entity.
Submit observations
POST a snapshot of flat facts from your own crawler, a vendor feed or your CRM. The first snapshot establishes a baseline and emits nothing: there is not yet anything to compare it against.
Read typed events
Every later snapshot is diffed against the previous one. Events come back on that same call, and stay readable newest-first from the events endpoint.

Developer integration

Small surface, versioned, OpenAPI-first

Authenticate with Authorization: Bearer <key>. Every error returns a stable code and a requestId you can quote.

POST/v1/keysPublic. Emails a one-time claim token to the address you give it. No key is returned on this call, proving the mailbox is what stops anyone minting a key on your account.

POST/v1/keys/claimPublic. Spends the emailed token and returns the key, shown once: 25 monitored entities a month, no card.

POST/v1/monitorsCreate a monitor for a subject, optionally filtered to specific change kinds.

GET/v1/monitorsList every monitor on your account.

POST/v1/monitors/:id/snapshotsSubmit an observation. Returns any events detected against the previous snapshot.

GET/v1/monitors/:id/eventsRead detected events, newest first.

POST/v1/demo/detectPublic. Runs detection on two supplied observations. No key required: it is what the demo above calls.

curl -X POST https://changegraph-api.com/v1/monitors \
  -H "Authorization: Bearer $CHANGEGRAPH_KEY" \
  -H "content-type: application/json" \
  -d '{"subject":"Acme Corp","kinds":["pricing","hiring"]}'

Read the API reference OpenAPI specification

Python and TypeScript SDKs Service health: https://changegraph-api.com/health

Pricing

Priced per monitored entity, capped so a runaway job can’t surprise you

Every plan includes an allowance, then a per-unit overage. Overage is hard-capped per billing period, so your worst-case bill is the base price plus the cap, never more.

Developer

$299 /month

250 monitored entities included
$1.50 per additional monitored entity
Overage capped at $600 per period
Full API access, Python and TypeScript SDKs

Start with this plan

Stop finding out last.

The free tier is 25 monitored entities a month, no card. Create a key, post two observations of the same entity, and the second call comes back with typed events.

Get Free API Key Run the live demo

One email address, no password, no card. Prefer the terminal? The same key, in two calls:

curl -X POST https://changegraph-api.com/v1/keys \
  -H "content-type: application/json" \
  -d '{"email":"you@company.com","name":"Evaluation key","source":{"source":"web","medium":"landing"}}'

# 202 Accepted. A one-time token is emailed to that address — spend it,
# and the response carries the key, shown once.

curl -X POST https://changegraph-api.com/v1/keys/claim \
  -H "content-type: application/json" \
  -d '{"token":"<token from the email>"}'

You already collect the data. Nothing in your stack says what changed.

You didn’t know something important changed.

You find out too late

Your team is manually watching

Most changes are noise

Late awareness never arrives as a line item. It arrives as a lost deal.

ChangeGraph turns changes into events.

Monitored

Detected

Classified

Evidence retained

Structured event

Into your workflow

This is what a material change looks like when it reaches your code.

Confidence is derived, not asserted

Evidence on every event

You supply the observations

Three calls from zero to a stream of typed events

Create a monitor

Submit observations

Read typed events

Small surface, versioned, OpenAPI-first

Priced per monitored entity, capped so a runaway job can’t surprise you

Stop finding out last.