Pricing

from $5.00 / 1,000 url checkeds

Semantic Change Detector

Monitor web pages for meaningful content changes, ignoring noisy timestamps and counters. Optional webhook alerts on change. $0.005/URL + $0.02 start.

Pricing

from $5.00 / 1,000 url checkeds

Rating

0.0

(0)

Developer

ando

Actor stats

Bookmarked

Total users

Monthly active users

4 days ago

Last modified

.gitignore

node_modules/
dist/
storage/
.apify_storage/
apify_storage/
.env
*.log
.DS_Store

package.json

{
  "name": "apify-semantic-change-detector",
  "version": "1.0.0",
  "description": "Detect meaningful page content changes",
  "type": "module",
  "main": "dist/main.js",
  "scripts": {
    "build": "tsc -p tsconfig.json",
    "start": "node dist/main.js",
    "prestart": "npm run build"
  },
  "engines": { "node": ">=20" },
  "dependencies": {
    "apify": "^3.4.4",
    "cheerio": "^1.0.0",
    "zod": "^3.25.76"
  },
  "devDependencies": {
    "@types/node": "^22.15.32",
    "typescript": "^5.9.3"
  }
}

tsconfig.json

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "outDir": "dist",
    "rootDir": "src",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true
  },
  "include": ["src/**/*.ts"]
}

.actor/Dockerfile

FROM apify/actor-node:20 AS builder

COPY package*.json ./
RUN npm install --include=dev

COPY . ./
RUN npx tsc -p tsconfig.json

FROM apify/actor-node:20
COPY --from=builder /usr/src/app/package*.json ./
RUN npm install --omit=dev
COPY --from=builder /usr/src/app/dist ./dist
COPY --from=builder /usr/src/app/.actor ./.actor
COPY --from=builder /usr/src/app/README.md ./README.md

CMD ["node", "dist/main.js"]

.actor/actor.json

{
  "actorSpecification": 1,
  "name": "semantic-change-detector",
  "title": "Semantic Change Detector",
  "description": "Monitor web pages for meaningful content changes, ignoring noisy timestamps and counters. Optional webhook alerts on change. $0.005/URL + $0.02 start.",
  "seoTitle": "Semantic Change Detector | Meaningful Website Monitoring",
  "seoDescription": "Track web pages for real content changes while ignoring timestamps, view counts, and other noise. Get diffs and webhook alerts. Pay $0.005 per URL checked.",
  "version": "1.0",
  "buildTag": "latest",
  "output": "./output_schema.json",
  "storages": {
    "dataset": "./dataset_schema.json"
  },
  "dockerfile": "./Dockerfile",
  "input": "./input_schema.json",
  "meta": {
    "generatedBy": "Cursor Auto with Composer"
  },
  "categories": ["MONITORING"],
  "pricingInfos": [
    {
      "pricingModel": "PAY_PER_EVENT",
      "pricingPerEvent": {
        "actorChargeEvents": {
          "apify-actor-start": {
            "eventTitle": "Actor Start",
            "eventDescription": "Charged when the Actor starts running. Number of events charged depends on Actor memory (one event per GB, minimum one event).",
            "isOneTimeEvent": true,
            "eventPriceUsd": 0.02
          },
          "url-checked": {
            "eventTitle": "URL Checked",
            "eventDescription": "Charged per URL checked for meaningful content changes",
            "isOneTimeEvent": false,
            "eventPriceUsd": 0.005,
            "isPrimaryEvent": true
          }
        }
      }
    }
  ]
}

.actor/dataset_schema.json

{
    "actorSpecification": 1,
    "fields": {
        "url": { "type": "string", "title": "URL" },
        "changed": { "type": "boolean", "title": "Changed" },
        "change_summary": { "type": "string", "title": "Summary" },
        "diff_excerpt": { "type": "string", "title": "Diff excerpt" },
        "checked_at": { "type": "string", "title": "Checked at" },
        "error": { "type": "string", "title": "Error" }
    },
    "views": {
        "overview": {
            "title": "Change checks",
            "transformation": {
                "fields": ["url", "changed", "change_summary", "diff_excerpt", "checked_at", "error"]
            },
            "display": {
                "component": "table",
                "properties": {
                    "url": { "label": "URL", "format": "link" },
                    "changed": { "label": "Changed", "format": "boolean" },
                    "change_summary": { "label": "Summary", "format": "text" },
                    "diff_excerpt": { "label": "Diff", "format": "text" },
                    "checked_at": { "label": "Checked at", "format": "date" },
                    "error": { "label": "Error", "format": "text" }
                }
            }
        }
    }
}

.actor/input_schema.json

{
    "title": "Semantic Change Detector Input",
    "type": "object",
    "schemaVersion": 1,
    "properties": {
        "urls": {
            "title": "URLs",
            "type": "array",
            "description": "List of web pages to check for content changes.",
            "editor": "stringList",
            "prefill": [
                "https://example.com"
            ],
            "minItems": 1
        },
        "selector": {
            "title": "CSS Selector",
            "type": "string",
            "editor": "textfield",
            "description": "Optional CSS selector to scope extraction to a specific part of the page (e.g. \"main\", \"#content\", \".article-body\"). If omitted, the full <body> text is used."
        },
        "sensitivity": {
            "title": "Sensitivity",
            "type": "string",
            "editor": "select",
            "enum": ["any", "meaningful"],
            "enumTitles": ["Any change (raw text diff)", "Meaningful change (ignore timestamps & counters)"],
            "default": "meaningful",
            "description": "\"meaningful\" strips common timestamps, relative dates, clock times, and engagement counters (views/likes/comments) before comparing, to avoid false positives from auto-updating widgets. \"any\" compares the raw extracted text verbatim."
        },
        "webhookUrl": {
            "title": "Webhook URL",
            "type": "string",
            "editor": "textfield",
            "description": "Optional URL to receive a fire-and-forget JSON POST notification whenever a change is detected on any of the input URLs."
        }
    },
    "required": ["urls"],
    "additionalProperties": false
}

.actor/output_schema.json

{
  "actorOutputSchemaVersion": 1,
  "title": "Outputs",
  "properties": {
    "results": {
      "title": "Results",
      "template": "{{links.apiDefaultDatasetUrl}}/items",
      "type": "string"
    },
    "resultsCsv": {
      "title": "Results (CSV)",
      "template": "{{links.apiDefaultDatasetUrl}}/items?format=csv",
      "type": "string"
    },
    "run": {
      "title": "Run in Console",
      "template": "{{links.consoleRunUrl}}",
      "type": "string"
    }
  }
}

src/lib.ts

1import { createHash } from 'node:crypto';
2import { load } from 'cheerio';
3
4/** CSS selectors for elements that typically hold one "line" of readable content. */
5const BLOCK_SELECTOR = 'p, li, h1, h2, h3, h4, h5, h6, td, th, blockquote, pre, dt, dd, figcaption, caption, summary';
6
7/**
8 * Regex heuristics used to strip volatile, non-meaningful content (timestamps,
9 * relative times, clock times, and engagement counters) before hashing/diffing
10 * a page's text under "meaningful" sensitivity. These are best-effort heuristics,
11 * not a guarantee — some volatile content may slip through, and rarely some
12 * meaningful content containing numbers may be stripped.
13 */
14const VOLATILE_PATTERNS: RegExp[] = [
15    // ISO 8601 timestamps, e.g. 2026-07-23T12:00:00Z
16    /\b\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2})?(\.\d+)?(Z|[+-]\d{2}:?\d{2})?\b/gi,
17    // Numeric dates, e.g. 07/23/2026, 23-07-2026, 2026.07.23
18    /\b\d{1,4}[/.-]\d{1,2}[/.-]\d{1,4}\b/g,
19    // Month-name dates, e.g. "Jul 23, 2026" / "23 July 2026"
20    /\b(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)[a-z]*\.?\s+\d{1,2}(st|nd|rd|th)?,?\s*\d{2,4}\b/gi,
21    /\b\d{1,2}(st|nd|rd|th)?\s+(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)[a-z]*\.?,?\s*\d{2,4}\b/gi,
22    // Clock times, e.g. 10:30, 10:30:00, 10:30 AM
23    /\b\d{1,2}:\d{2}(:\d{2})?\s*(am|pm)?\b/gi,
24    // Relative timestamps, e.g. "5 minutes ago", "just now", "yesterday"
25    /\b\d+\s*(second|minute|hour|day|week|month|year)s?\s+ago\b/gi,
26    /\b(just now|moments? ago|yesterday|today)\b/gi,
27    // Engagement counters, e.g. "1,234 views", "12 comments", "3.4k likes"
28    /\b[\d,.]+k?\+?\s*(views?|likes?|comments?|shares?|reads?|upvotes?|downvotes?|replies|followers?|subscribers?|reactions?)\b/gi,
29];
30
31/**
32 * Loads HTML and extracts an array of "lines" of readable text, one per
33 * block-level element (paragraphs, list items, headings, table cells, etc.).
34 * Falls back to splitting the raw text of the root element by newlines if no
35 * block elements are found (e.g. the selector targets a leaf node).
36 */
37export function extractLines(html: string, selector?: string): string[] {
38    const $ = load(html);
39    $('script, style, noscript, svg, template, link, meta').remove();
40
41    const root = selector ? $(selector) : $('body');
42    if (root.length === 0) {
43        return [];
44    }
45
46    const lines: string[] = [];
47    const blocks = root.find(BLOCK_SELECTOR);
48
49    if (blocks.length > 0) {
50        blocks.each((_, el) => {
51            const text = $(el).text().replace(/\s+/g, ' ').trim();
52            if (text) lines.push(text);
53        });
54    } else {
55        const text = root.text();
56        for (const raw of text.split(/\n+/)) {
57            const t = raw.replace(/\s+/g, ' ').trim();
58            if (t) lines.push(t);
59        }
60    }
61
62    return lines;
63}
64
65/** Strips volatile heuristic patterns from a single line of text. */
66export function stripVolatile(line: string): string {
67    let out = line;
68    for (const re of VOLATILE_PATTERNS) {
69        out = out.replace(re, ' ');
70    }
71    return out.replace(/\s+/g, ' ').trim();
72}
73
74/** Simple order-independent line diff: which lines were added / removed. */
75export function computeDiff(oldLines: string[], newLines: string[]): { added: string[]; removed: string[] } {
76    const oldSet = new Set(oldLines);
77    const newSet = new Set(newLines);
78    const added = newLines.filter((l) => !oldSet.has(l));
79    const removed = oldLines.filter((l) => !newSet.has(l));
80    return { added, removed };
81}
82
83export function sha256(input: string): string {
84    return createHash('sha256').update(input, 'utf8').digest('hex');
85}

src/main.ts

1import { Actor, log } from 'apify';
2import { z } from 'zod';
3import { computeDiff, extractLines, sha256, stripVolatile } from './lib.js';
4
5const InputSchema = z.object({
6    urls: z.array(z.string().min(1)).min(1, 'Provide at least one URL.'),
7    selector: z.string().optional(),
8    sensitivity: z.enum(['any', 'meaningful']).optional().default('meaningful'),
9    webhookUrl: z.string().url().optional(),
10});
11
12type Input = z.infer<typeof InputSchema>;
13
14const CHARGE_EVENT = 'url-checked';
15const STORE_NAME = 'semantic-change-snapshots';
16const CONCURRENCY = 5;
17const FETCH_TIMEOUT_MS = 30_000;
18const WEBHOOK_TIMEOUT_MS = 10_000;
19const MAX_STORED_LINES = 4_000;
20const MAX_DIFF_LINES = 8;
21const MAX_DIFF_EXCERPT_CHARS = 2_000;
22
23interface Snapshot {
24    hash: string;
25    lines: string[];
26    checkedAt: string;
27}
28
29interface CheckResult {
30    url: string;
31    changed: boolean;
32    change_summary: string;
33    diff_excerpt: string | null;
34    checked_at: string;
35    error?: string;
36}
37
38function normalizeUrl(raw: string): string {
39    const t = raw.trim();
40    if (!t) throw new Error('Empty URL');
41    return t.includes('://') ? t : `https://${t}`;
42}
43
44async function fetchHtml(url: string): Promise<string> {
45    const ac = new AbortController();
46    const t = setTimeout(() => ac.abort(), FETCH_TIMEOUT_MS);
47    try {
48        const res = await fetch(url, {
49            signal: ac.signal,
50            redirect: 'follow',
51            headers: {
52                'user-agent': 'Mozilla/5.0 (compatible; SemanticChangeDetector/1.0; +https://apify.com)',
53                accept: 'text/html,application/xhtml+xml',
54            },
55        });
56        if (!res.ok) {
57            throw new Error(`HTTP ${res.status} ${res.statusText}`);
58        }
59        return await res.text();
60    } finally {
61        clearTimeout(t);
62    }
63}
64
65function buildLines(html: string, selector: string | undefined, sensitivity: Input['sensitivity']): string[] {
66    const rawLines = extractLines(html, selector);
67    if (sensitivity === 'any') return rawLines;
68    return rawLines.map(stripVolatile).filter(Boolean);
69}
70
71function buildDiffExcerpt(added: string[], removed: string[]): string {
72    const parts: string[] = [];
73    for (const l of removed.slice(0, MAX_DIFF_LINES)) parts.push(`- ${l}`);
74    for (const l of added.slice(0, MAX_DIFF_LINES)) parts.push(`+ ${l}`);
75    let excerpt = parts.join('\n');
76    if (excerpt.length > MAX_DIFF_EXCERPT_CHARS) {
77        excerpt = `${excerpt.slice(0, MAX_DIFF_EXCERPT_CHARS)}…`;
78    }
79    return excerpt;
80}
81
82async function notifyWebhook(webhookUrl: string, payload: unknown): Promise<void> {
83    const ac = new AbortController();
84    const t = setTimeout(() => ac.abort(), WEBHOOK_TIMEOUT_MS);
85    try {
86        const res = await fetch(webhookUrl, {
87            method: 'POST',
88            signal: ac.signal,
89            headers: { 'content-type': 'application/json' },
90            body: JSON.stringify(payload),
91        });
92        if (!res.ok) {
93            log.warning(`Webhook POST to ${webhookUrl} returned HTTP ${res.status}`);
94        }
95    } catch (err) {
96        log.warning(`Webhook POST to ${webhookUrl} failed: ${err instanceof Error ? err.message : String(err)}`);
97    } finally {
98        clearTimeout(t);
99    }
100}
101
102async function checkUrl(rawUrl: string, input: Input, store: Awaited<ReturnType<typeof Actor.openKeyValueStore>>): Promise<CheckResult> {
103    const checkedAt = new Date().toISOString();
104    // Key-value store keys may only contain a-zA-Z0-9!-_.'() — ":" is not allowed, so we use "_" as the separator.
105    const key = `snapshot_${sha256(rawUrl)}`;
106
107    try {
108        const target = normalizeUrl(rawUrl);
109        const html = await fetchHtml(target);
110        const lines = buildLines(html, input.selector, input.sensitivity);
111        const joined = lines.join('\n');
112        const hash = sha256(joined);
113
114        const previous = await store.getValue<Snapshot>(key);
115
116        const snapshot: Snapshot = {
117            hash,
118            lines: lines.slice(0, MAX_STORED_LINES),
119            checkedAt,
120        };
121        await store.setValue(key, snapshot);
122
123        if (!previous) {
124            return {
125                url: rawUrl,
126                changed: false,
127                change_summary: 'No previous snapshot found. Baseline stored for future comparisons.',
128                diff_excerpt: null,
129                checked_at: checkedAt,
130            };
131        }
132
133        if (previous.hash === hash) {
134            return {
135                url: rawUrl,
136                changed: false,
137                change_summary: 'No change detected since last check.',
138                diff_excerpt: null,
139                checked_at: checkedAt,
140            };
141        }
142
143        const { added, removed } = computeDiff(previous.lines, lines);
144        const change_summary = `Content changed: ${added.length} line(s) added, ${removed.length} line(s) removed.`;
145        const diff_excerpt = buildDiffExcerpt(added, removed);
146
147        if (input.webhookUrl) {
148            // Fire-and-forget: webhook delivery never blocks or fails the run.
149            void notifyWebhook(input.webhookUrl, {
150                url: rawUrl,
151                changed: true,
152                change_summary,
153                diff_excerpt,
154                checked_at: checkedAt,
155            });
156        }
157
158        return { url: rawUrl, changed: true, change_summary, diff_excerpt, checked_at: checkedAt };
159    } catch (err) {
160        const message = err instanceof Error ? err.message : String(err);
161        return {
162            url: rawUrl,
163            changed: false,
164            change_summary: 'Check failed.',
165            diff_excerpt: null,
166            checked_at: checkedAt,
167            error: message,
168        };
169    }
170}
171
172await Actor.init();
173
174const chargingManager = Actor.getChargingManager();
175await chargingManager.init();
176const pricingInfo = chargingManager.getPricingInfo();
177let chargeLimitReached = false;
178
179function remainingCharges(): number {
180    if (!pricingInfo.isPayPerEvent) return Number.POSITIVE_INFINITY;
181    return chargingManager.calculateMaxEventChargeCountWithinLimit(CHARGE_EVENT);
182}
183
184try {
185    const input = InputSchema.parse((await Actor.getInput()) ?? {});
186    const urls = [...new Set(input.urls.map((u) => u.trim()).filter(Boolean))];
187
188    if (urls.length === 0) {
189        throw new Error('No URLs provided.');
190    }
191
192    const store = await Actor.openKeyValueStore(STORE_NAME);
193    const dataset = await Actor.openDataset();
194
195    log.info(`Checking ${urls.length} URL(s) (sensitivity=${input.sensitivity})...`);
196
197    const active = new Set<Promise<void>>();
198
199    const processOne = async (url: string) => {
200        if (chargeLimitReached) return;
201        if (remainingCharges() <= 0) {
202            chargeLimitReached = true;
203            log.warning('Max total charge limit reached. Stopping further processing.');
204            return;
205        }
206
207        const result = await checkUrl(url, input, store);
208        await dataset.pushData(result);
209
210        try {
211            const chargeRes = await Actor.charge({ eventName: CHARGE_EVENT, count: 1 });
212            if (chargeRes?.eventChargeLimitReached) {
213                chargeLimitReached = true;
214                log.warning('Charge limit reached during this run. Stopping further processing.');
215            }
216        } catch (chargeErr) {
217            log.debug(`PPE charge skipped: ${chargeErr}`);
218        }
219
220        log.info(`${url}: ${result.changed ? 'CHANGED' : 'unchanged'}${result.error ? ` (error: ${result.error})` : ''}`);
221    };
222
223    for (const url of urls) {
224        if (chargeLimitReached) break;
225        const p = processOne(url).finally(() => active.delete(p));
226        active.add(p);
227        if (active.size >= CONCURRENCY) await Promise.race(active);
228    }
229
230    await Promise.all(active);
231
232    log.info(chargeLimitReached ? 'Stopped early due to charge limit.' : 'Done.');
233} catch (err) {
234    const message = err instanceof Error ? err.message : String(err);
235    log.error(`Actor failed: ${message}`);
236    throw err;
237} finally {
238    await Actor.exit();
239}

Semantic Change Detector

andok/semantic-change-detector

Monitor web pages for meaningful content changes, ignoring noisy timestamps and counters. Optional webhook alerts on change. $0.005/URL + $0.02 start.

Andok

Website Change Monitor

vedder1980/website-change-monitor

Monitor critical web pages for meaningful changes and generate a clean change log for alerts, competitor tracking, and content watchlists.

Daniel Ferreira de Almeida

Website Change & Compliance Monitor

monema/apify-change-monitor

Monitor public pages, policy documents, listings, and competitor content for meaningful changes with persistent state and webhook alerts.

Maarten Vreeburg

Website Change Tracker – Competitor & Content Monitor

conceivable_extension/website-change-tracker

Monitor any web page for content changes. Detects price updates, policy edits, competitor announcements, and new content. Stores page snapshots and alerts on meaningful diffs. PPE: $0.002 no change, $0.008 changed.

joseph fadero

Web Page Change Monitor - Track Website Changes & Get Alerts

scrappy_garden/web-page-change-monitor

Monitor any website for changes automatically. Track content updates, price changes, product availability, news updates. Get instant alerts when pages change. Perfect for competitor monitoring, price tracking, content surveillance, and automated change detection. Export change history to JSON.

Bikram Adhikari

Website Change Detector

technicaldost/website-change-detector

Monitor websites for content changes with visual comparison. Get alerts when pages update.

Technical Dost Solutions

Competitor Change Monitor API

s3nafps/competitor-change-monitor-api

Detect meaningful text changes on public competitor pages between Apify actor runs.

mohamed senator

Website Change Monitor & Alerter

second_coming/website-change-monitor

Monitor web pages for content changes. Track page diffs, get webhook alerts when monitored pages change. Supports CSS selectors for targeting specific sections.

Richard P

Firecrawl Website Change Monitor - Track Page Changes with AI

alizarin_refrigerator-owner/firecrawl-website-change-monitor---track-page-changes-with-ai

Monitor websites for content changes. Get notified when pricing, inventory, competitor pages, or any web content changes. Uses Firecrawl for intelligent change detection. Markdown Comparison JSON Extraction Change Notifications Webhook Integration Scheduled Monitoring

The Howlers

Page Watch — Website Change Monitor & Content Tracker

mfapitools/page-watch

Monitor any URL for content changes with hash-based change detection. Pay per check + per detected change. Ideal for watching competitor pages, docs, pricing, or any public web page.