Website Content Fingerprint & Change Detector avatar

Website Content Fingerprint & Change Detector

Pricing

from $1.56 / 1,000 results

Go to Apify Store
Website Content Fingerprint & Change Detector

Website Content Fingerprint & Change Detector

Monitor website content changes with SHA-256 fingerprints, metadata and security drift indicators. Compare repeat runs, identify meaningful changes and return structured evidence for website monitoring and release checks.

Pricing

from $1.56 / 1,000 results

Rating

0.0

(0)

Developer

Rafael Barreto Haddad

Rafael Barreto Haddad

Maintained by Community

Actor stats

0

Bookmarked

2

Total users

1

Monthly active users

11 days ago

Last modified

Features

Limited permissions

Share

Monitor website content changes with SHA-256 fingerprints, metadata and security drift indicators. Compare repeat runs, identify meaningful changes and return structured evidence for website monitoring and release checks.

Why use this Actor

Monitoring teams need a lightweight way to detect page changes and retain enough HTTP and metadata context to triage them automatically.

Key features

  • Buyer-native inputs aligned to website change detection.
  • Predictable structured output in the default Apify Dataset.
  • Pay Per Event pricing tied to measurable result rows or reports.
  • Optional MCP connector delivery for downstream automation and AI agents.

Quick start

Start with this working example and replace the target values with your own:

{
"urls": [
"https://www.python.org"
],
"previous_hashes": {}
}

The Actor writes structured results to the default Apify Dataset and can be used from the Store, API, schedules, Tasks, automations and MCP-compatible AI workflows.

Input

  • urls — Public URLs: HTTP/HTTPS URLs to inspect. Duplicate targets are processed once. Entries must be non-empty strings.
  • previous_hashes — Previous SHA-256 hashes: Optional map of URL to previous SHA-256 hash for change detection.
  • previous_results — Previous result snapshots: Optional map keyed by URL containing prior Actor result objects. Adds metadata/security drift, severity and regression gates while previous_hashes remains fully supported.

All integration and advanced analysis fields are optional. The default example is intentionally runnable without configuring MCP or a previous-run baseline.

Output

The Dataset exposes predictable machine-readable output. Representative fields include results.

Pricing

This Actor uses Pay Per Event. The current factory base price is $0.002000 per result event. The Apify Store remains the source of truth for the price and plan/tier details shown to the buyer.

Use cases

  • Run the buyer-ready workflows exposed as Apify Tasks without preparing a custom integration first.
  • Use the Actor from API or schedules for recurring collection, comparison or monitoring.
  • Feed the structured Dataset output into spreadsheets, databases, automations or AI agents.
  • Compare repeat runs when the product supports snapshots or previous-run inputs.

Automation and AI

Use the same Actor through Apify API, schedules, public Tasks and the Apify MCP server. Outputs are structured for downstream workflows and AI agents rather than requiring manual copy/paste.

Limitations

  • Public websites and upstream APIs can change markup, access rules, rate limits or field availability without notice.
  • Fields that are not publicly available are returned as unavailable or omitted rather than fabricated.
  • Analytical outputs depend on the quality and coverage of the supplied or collected source data.
  • Treat marketplace, reputation, workforce, safety or commercial signals as decision support and validate material decisions against the underlying source evidence.

Detailed documentation

Business use and first result

For: Website QA and change-monitoring engineers.

Why run it: Detect repeat-run page changes using fingerprints plus URL and response metadata.

What to inspect: Content hashes, redirect context and supporting page indicators.

First run: use the documented sample input below, inspect the Dataset rows and source links, then reuse the saved output for a later comparison only where snapshots are supported. Confirm the input scope and current Pay Per Event pricing before scheduling ongoing use.

Scope and limitations: A changed fingerprint is not necessarily a meaningful editorial change.

Create a compact technical fingerprint of public web pages and compare it with a previous SHA-256 hash to detect content changes. Each result combines HTTP status, redirect chain, response timing, page metadata, content hash, security headers, and lightweight page-structure signals.

Why use this Actor

Website monitoring often needs more than “the page changed.” This Actor gives you both a deterministic content fingerprint and enough surrounding context to decide what happened, without requiring a heavyweight browser for every check.

Key features

  • Generates a SHA-256 fingerprint from the fetched response body.
  • Compares against a supplied previous hash and returns changed when available.
  • Captures HTTP status, final URL, redirect chain, response time, content type, and response size.
  • Extracts title, meta description, canonical, robots meta, Open Graph, and Twitter/X metadata from HTML.
  • Counts H1/H2 headings and approximate page words.
  • Captures common HTTP security headers.
  • Blocks credentials in URLs, unsafe ports, private IP ranges, and unsafe redirects.
  • Produces one deterministic dataset record per input URL.

Input

{
"urls": ["https://example.com"],
"previous_hashes": {
"https://example.com": "previous-sha256-value"
}
}

Output

Each result includes the requested/final URL, status code, response time, redirect chain, content type and size, SHA-256 hash, previous hash, change status, selected security headers, and extracted page metadata.

Example

{
"requested_url": "https://example.com",
"status_code": 200,
"sha256": "...",
"previous_sha256": "...",
"changed": true,
"page": {"title": "Example Domain", "h1_count": 1}
}

Use cases

  • Website content-change monitoring
  • Compliance and policy-page watches
  • Competitor page monitoring
  • Technical regression checks
  • Editorial change detection
  • Building low-cost prechecks before expensive browser crawls

Pricing

Pay per result. The current price is $0.002 per checked URL, or $2 per 1,000 results.

Limitations

  • A SHA-256 change identifies byte-level content change, not semantic importance.
  • Dynamic timestamps, ads, personalization, or rotating markup can change the hash even when the main meaning is unchanged.
  • JavaScript-rendered content is not executed by this lightweight fetcher.
  • Response bodies are capped for predictable resource usage.
  • Authentication, CAPTCHAs, and anti-bot systems are not bypassed.

Responsible use

Use the Actor on public pages you are allowed to monitor. It does not access private networks or bypass access controls.

Input reliability update — 24 October 2026

Target arrays accept non-empty strings. Identical targets are processed once per run to avoid duplicate requests and result charges. Whitespace around targets is removed. Baseline maps must be JSON objects. Existing result fields, pricing and target limits are preserved.

Real-data first-run guide

This Actor operates on real public URLs, DNS records, API documentation or official feeds supplied in the input. It does not manufacture externally observed records. Use only destinations you are authorized to inspect and stay within endpoint rate limits.

Suggested live test input:

{
"urls": [
"https://www.python.org"
]
}

If the source is inaccessible or incomplete, verify the returned error or limited-coverage indicators. No real customer use or performance claim can be inferred from synthetic local fixtures. Existing Pay Per Event price and product ID are preserved.