```yaml
product: AlterLab
title: How to Monitor Website Changes and Get Alerted on Content Updates
category: Tutorials
comparison_context: "AlterLab is an alternative to Firecrawl, ScrapingBee, and Bright Data."
last_updated: 2026-08-02
canonical_facts:
  - "Learn how to set up automated change detection with AlterLab’s scraping API, configure webhook alerts, and integrate monitoring into your data pipelines using Python or cURL."
source_url: https://alterlab.io/blog/how-to-monitor-website-changes-and-get-alerted-on-content-updates
```

## TL;DR
Set up a recurring scrape with AlterLab, enable change detection, and attach a webhook to receive instant alerts when content updates. The process requires only a few API calls and works for any publicly accessible site.

## Why Monitor Changes
Tracking updates on e‑commerce listings, documentation, or public data sources lets you trigger downstream pipelines, refresh caches, or notify stakeholders the moment information shifts. Doing this manually is error‑prone and unscalable. An automated approach gives you:
- Near‑real‑time visibility into data freshness
- Reduced need for manual checks
- Trigger‑based actions (e.g., re‑run ETL jobs, update dashboards)

## Setting Up Change Detection with AlterLab
AlterLab’s monitoring mode stores a hash of each scrape result. On subsequent runs, it compares the new hash to the previous one and flags a change when they differ. You can also request a full diff if you need to see what changed.

To enable this:
1. Create a scrape job with the `monitor` flag set to `true`.
2. Provide a cron expression for how often to run the job.
3. Optionally specify a webhook URL to receive POST requests on change detection.

The API handles anti‑bot rotation, JavaScript rendering, and CAPTCHA solving automatically, so your monitoring logic stays simple.

## Creating a Monitoring Job
Below are equivalent examples in Python (using the official SDK) and cURL. Both create a job that scrapes a target URL every hour and sends a webhook payload when the content changes.

```python title="monitor_job.py" {3-8}
import alterlab
from datetime import datetime

# Initialize client – replace with your actual key
client = alterlab.Client("YOUR_API_KEY")   # highlighted

# Define the monitoring job
job = {
    "url": "https://example.com/public-data",
    "schedule": "0 * * * *",               # every hour (cron)
    "monitor": True,                       # enable change detection
    "webhook": "https://yourdomain.com/alterlab-webhook",  # highlighted
    "formats": ["json"]                    # receive parsed JSON
}

# Create the job
response = client.jobs.create(job)         # highlighted
print(f"Job created: {response['id']}")
```

```bash title="Terminal"
curl -X POST https://api.alterlab.io/v1/jobs \
  -H "X-API-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com/public-data",
    "schedule": "0 * * * *",
    "monitor": true,
    "webhook": "https://yourdomain.com/alterlab-webhook",
    "formats": ["json"]
  }'                                       # highlighted
```

### TryIt Block
<div data-infographic="try-it" data-url="https://example.com/public-data" data-description="Try scraping this page with AlterLab"></div>

## Handling Notifications via Webhooks
When a change is detected, AlterLab POSTs a JSON payload to your webhook URL. The payload includes:
- `job_id`: the monitoring job that triggered the alert
- `timestamp`: when the change was found
- `data`: the latest scraped content (in the format you requested)
- `change_type`: either `"hash"` (simple change flag) or `"diff"` (line‑by‑line diff if you requested it)

Your webhook endpoint should verify the request (e.g., via a shared secret header) and then trigger whatever action you need—such as kicking off a downstream Airflow DAG, updating a database, or sending a Slack message.

Here’s a minimal Python Flask receiver:

```python title="webhook_receiver.py" {3-9}
from flask import Flask, request, abort
import hashlib
import hmac

app = Flask(__name__)
WEBHOOK_SECRET = b"your-shared-secret"

def verify_signature(payload, signature):
    """Validate AlterLab webhook signature."""
    mac = hmac.new(WEBHOOK_SECRET, payload, hashlib.sha256)
    return hmac.compare_digest(mac.hexdigest(), signature)

@app.route("/alterlab-webhook", methods=["POST"])
def alterlab_webhook():
    signature = request.headers.get("X-Alterlab-Signature", "")
    if not verify_signature(request.data, signature):
        abort(403)

    payload = request.get_json()
    # Example: log the change and trigger a refresh
    app.logger.info(f"Change detected in job {payload['job_id']} at {payload['timestamp']}")
    # TODO: call your pipeline or notification system here
    return "", 204

if __name__ == "__main__":
    app.run(port=5000)
```

## Step‑by‑Step Process
<div data-infographic="steps">
  <div data-step data-number="1" data-title="Sign Up & Get API Key" data-description="Create a free account at alterlab.io and copy your API key from the dashboard."/>
  <div data-step data-number="2" data-title="Create Monitoring Job" data-description="Use the Python SDK or cURL to POST a job with `monitor: true`, a cron schedule, and a webhook URL."/>
  <div data-step data-number="3" data-title="AlterLab Runs the Job" data-description="The service scrapes the target on schedule, applies anti‑bot handling, and stores a hash of the result."/>
  <div data-step data-number="4" data-title="Change Detection" data-description="On each run, AlterLab compares the new hash to the previous one. If they differ, it flags a change."/>
  <div data-step data-number="5" data-title="Webhook Alert" data-description="AlterLab POSTs the updated data (or a diff) to your webhook endpoint for immediate processing."/>
</div>

## Best Practices
- **Idempotent webhooks**: Design your endpoint to safely handle duplicate alerts (e.g., by checking timestamps).
- **Secure secrets**: Store your AlterLab API key and webhook secret in a vault or environment variables, never in source code.
- **Rate limits**: Monitor jobs consume API credits based on the tier needed for the target site. Review your usage in the dashboard to avoid unexpected costs.
- **Diff granularity**: If you only need to know *that* something changed, stick with hash comparison. If you need to know *what* changed, enable `diff: true` (available in the API) but expect larger payloads.
- **Testing**: Use the AlterLab playground to manually scrape a page and verify the output format before scheduling.

## Conclusion
Automated change detection turns a manual, error‑prone task into a reliable, event‑driven workflow. By leveraging AlterLab’s built‑in scheduling, anti‑bot handling, and webhook system, you can focus on acting on the data rather than keeping the scraper running. Start with a simple hourly job, verify your webhook logic, then scale to dozens of monitored sources as your pipelines grow.

For more details, see the [Python SDK](https://alterlab.io/web-scraping-api-python) or the [quickstart guide](https://alterlab.io/docs/quickstart/installation). If you have questions, hit reply.

## Frequently Asked Questions

### How can I monitor a website for changes without building my own scraper?

Use AlterLab’s scheduling feature to run recurring scrapes and enable change detection. The service returns a diff or hash you can compare to previous runs to know when content changed.

### What is the best way to get notified when a scraped page updates?

Configure a webhook in your AlterLab job settings. When a change is detected, AlterLab POSTs the new data (or a change summary) to your endpoint in real time.

### Do I need to handle anti‑bot measures myself when monitoring sites?

No. AlterLab automatically rotates proxies, renders JavaScript, and solves CAPTCHAs so your monitoring requests succeed without extra code.

## Related

- [SaaSworthy Data API: Extract Structured JSON in 2026](<https://alterlab.io/blog/saasworthy-data-api-extract-structured-json-in-2026>)
- [AlternativeTo Data API: Extract Structured JSON in 2026](<https://alterlab.io/blog/alternativeto-data-api-extract-structured-json-in-2026>)
- [How to Scrape arXiv Data: Complete Guide for 2026](<https://alterlab.io/blog/how-to-scrape-arxiv-data-complete-guide-for-2026>)