# Website Change Monitor for Prices & Terms (`futurescash/price-terms-change-evidence`) Actor

Track price changes, website updates and terms changes. Watch competitor prices, subscription plans and privacy policies. Add page links and compare old and new text. No coding required. Public static HTML only. $0.50 per 1,000 successful checks; failed checks are free.

- **URL**: https://apify.com/futurescash/price-terms-change-evidence.md
- **Developed by:** [Björn Norman](https://apify.com/futurescash) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.50 / 1,000 successful page checks

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

**See when a website changes its prices or terms — and read the old and new text.**

Want to track price changes, watch competitor prices or check whether a website has changed? Add the page links you want to watch. No coding is required.

Run the tool once to save a starting point. Run it again later to compare the old and new text. The results show which pages changed, which stayed the same and which could not be checked.

### What can this website change monitor do?

- **Competitor price monitoring:** check a competitor's public pricing page for changes to its prices or offers.
- **Subscription plan tracking:** check for subscription price increases, changed fees, included features and usage limits over time.
- **Terms and conditions monitoring:** see terms changes, privacy policy updates and changes to refund or cancellation policies.
- **Website content change detection:** check website updates, product description changes or edited announcements on public pages, or focus on one section.

This is a website change detector for public **static HTML** pages: pages whose text is available without running JavaScript. It does not support pages behind a login. It compares text; it does not match products across shops or decide what a legal change means.

### A simple example

You want to watch a competitor's subscription page:

| Check | Page text | What you learn |
| --- | --- | --- |
| First run | Basic plan: $19 per month | Starting point saved. |
| A later run | Basic plan: $24 per month | The text changed. Review the old and new wording. |

*Illustrative example, not a live customer result.* If the page is unchanged, the result says so. If it cannot be read, you get an error instead of a successful check.

### Ready-to-run example: track subscription prices and plan changes

**Has a supplier raised its prices or reduced what a plan includes?** Start with our [ready-to-run pricing example](https://apify.com/futurescash/price-terms-change-evidence/examples/track-saas-price-increases-and-plan-changes). It watches the public Fathom Analytics pricing page. The page link, monitor name and page section are already filled in.

This is useful for someone reviewing a software budget or keeping an eye on a competitor's offer. You get evidence of changed wording to review before deciding what to do.

#### Try it in three steps

1. **Use the example and run it once.** Your result should say `baseline`: the starting text has been saved in your own account.
2. **Run the same saved task again later.** Keep its monitor name, page link and section unchanged. `unchanged` means no text change was found; `changed` means there is wording to review. An immediate second run will usually be unchanged.
3. **Open Change evidence in the results.** Compare **Previous text** and **New text**. For a large rewrite, inspect **Before large rewrite** and **After large rewrite** instead. Those excerpts can include unchanged lines. If **Evidence shortened** is true, the excerpt is incomplete. An `error` row means the check failed, not that the price stayed the same.

**What it watches:** the default prices, plan descriptions, included features and other text returned in the pricing page's main section. It does not click billing-period switches or load prices that appear only after JavaScript runs. A changed row is a prompt to review the page, not proof of a price increase: page wording or layout may have changed too.

**Make it yours:** replace the example URL with a supported public pricing page. Use a new monitor name, such as `my-supplier-pricing`. The example uses `main` to skip navigation and footer text; clear Page section if your page has no main section. Start with one page and check that its saved text contains the prices or terms you need. The latest text is in the monitor's named Key-Value Store under Storage in Apify Console.

**Cost:** one page checked daily for 30 days is 30 successful checks, or **$0.015 at the current rate**. First baselines and unchanged checks count; failed checks are free. A schedule is optional and must be set up separately in Apify. This example creates no schedule and sends no automatic alerts.

Fathom is an independent example website, not our customer or partner. Its page can change or become unavailable. Our illustrated $19-to-$24 change above is fictional; it is not a claim about Fathom's prices.

### What does it cost?

**$0.50 per 1,000 successful page checks. Failed checks are free.**

One check means reading one page once. The first saved starting point and later unchanged pages also count. Checking 100 pages once a day for 30 days means 3,000 successful checks, costing **$1.50** for this tool. Your own Apify subscription, if any, is separate.

There is no start fee, extra fee for finding a change, or separate platform-usage fee for normal runs. You can set a maximum cost for each run. The live **Pricing** tab always shows the current price.

### Get started — no code required

1. Click **Try for free** to open the tool in Apify. An Apify account is required.
2. In **Public pages**, replace the example link with one to 100 page links you want to check.
3. Set a **Monitor name**, such as `competitor-prices`. Use that same name and the same links on later runs.
4. Leave **Page section (optional)** empty to compare the whole page. Start the run to save the first version.
5. Run again later and open the results table. Look for `changed` and review its before-and-after text. Open **Change evidence** for the before-and-after text, or JSON for all fields.

For an automatic daily or weekly check, create a schedule in Apify separately. Each run checks your list once. This tool does not create a schedule or send email or Slack alerts for you.

### Common questions — in plain English

#### How do I check if a website has changed?

Use this page change checker to compare a page with the last version you saved. It shows the old and new text. Your first run saves the starting point; it cannot reveal changes made before that run.

#### Can I track price drops and price increases?

Yes, when the price is in a supported page's text. This price change tracker helps you spot a lower or higher price on later checks. Read the before-and-after text to confirm the amount, currency and plan or item it belongs to.

#### Can I keep an eye on competitor prices?

Add your competitors' public pricing pages. Check for changes to offers, subscription prices, plan features or fees. Each page is compared with its own earlier version. Matching the same product across different shops requires a separate tool.

#### Can I see if terms or a privacy policy have changed?

Yes. Use it for terms of service changes, privacy policy monitoring, refund policy updates and cancellation terms. It shows wording changes for you to review. It does not explain their legal consequences.

#### Can it check websites every day or email me?

Daily website checks are possible by setting up a schedule in Apify. Email notifications require a separate integration; this tool does not send alerts itself. Each successful scheduled check has the same listed price.

#### Does it work on any website?

It reads public static HTML: text the website sends immediately, without running scripts or signing in. Some shops load prices later with JavaScript and are not supported. Start with one page, inspect the saved text, and confirm that the information you need was captured.

#### I am not technical. How do I get started or ask for help?

Follow **Get started — no code required** above. Begin with one page and leave **Page section (optional)** empty. To ask a setup question, open the **Issues** tab on this product and describe what you want to watch. Include a public page link if useful. Questions are public, so leave out passwords and private information.

### På svenska: prisbevakning och ändringar på webbsidor

Vill du bevaka priser, följa konkurrenters priser eller se om en webbsida har ändrats? Lägg in sidans länk. Första körningen sparar texten; nästa körning visar vad som har ändrats. Du kan exempelvis upptäcka prissänkningar, prishöjningar och ändrade villkor. Verktyget läser offentliga sidor där texten finns direkt, utan inloggning eller extra sidprogram. Det skickar inga mejl automatiskt. Behöver du hjälp, skriv en fråga under **Issues**. Frågan blir offentlig.

### For developers: input and results

You can also use the API with this input:

```json
{
  "urls": ["https://example.com/"],
  "monitorName": "my-pricing-monitor",
  "selector": ""
}
```

To check one section, use a simple tag such as `main`, an ID such as `#pricing`, or a class such as `.price`. Leave `selector` empty for all static body text.

### Results

| Status | Meaning | Charged? |
| --- | --- | --- |
| `baseline` | First successful observation of this URL and section. | Yes |
| `unchanged` | No content change, including a valid HTTP 304 response. | Yes |
| `noise_only` | Only content filtered by the documented rules changed. | Yes |
| `changed` | Text changed; inspect the before-and-after evidence. | Yes |
| `error` | The page could not be checked successfully. The previous baseline is preserved. | No |

Use **Checks** for an overview, **Change evidence** for old and new text, and JSON for all fields. Results include the URL, status and error information when relevant. Change records include evidence and rule-based categories for review. A completed run can contain error rows; always inspect each row's status. The first baseline says nothing about changes before that observation.

Large rewrites return a bounded before-and-after region. It may include unchanged interior lines, and evidence can be truncated. The tool does not claim an exact edit count for such regions. Selected cookie-banner elements and leading copyright years are filtered; this is not a guarantee of zero false alarms.

### Billing details

Each successful check is $0.0005. The same price applies to the first baseline, an unchanged page and a changed page. Failed checks are not charged.

Set your maximum cost per run. The tool checks the remaining event budget before fetching the next page and stops when no further check can be charged. The minimum maximum-cost setting is the price of one check; this is a ceiling setting, not a minimum purchase charge. Remaining URLs are not processed after the limit is reached.

Evidence and the baseline are saved before requesting payment. If a payment outcome is uncertain, the run fails and resuming that same run skips the attempted charge to avoid duplicates. A delivered result may be free in this rare failure case. A separate new run is a new check. Result storage, baseline updates and charging are separate operations, so interrupted runs can produce duplicate evidence.

### History and concurrent runs

The latest successful snapshot is kept in a named Key-Value Store in the running user's account. Reuse the same `monitorName`, exact URL and selector to compare with it. Changing any of these creates a separate baseline. The schema/configuration version also isolates incompatible snapshots.

Cloud runs acquire a monitor lock. An overlapping invocation fails without checking pages. If a run is forcibly stopped, that monitor can remain busy for up to ten minutes. Run local invocations sequentially. Previous result datasets follow your Apify retention settings. Remove obsolete named baseline stores and lock queues when their history is no longer needed.

### Supported pages and limits

**Early release.** Detection uses deterministic rules. It does not assess legal meaning or guarantee that every important change will be found. Review the evidence before acting.

- Public HTTP/S static HTML on standard ports, with no authentication. DNS and redirects are checked to reject private-network targets.
- One simple selector only; no compound CSS selectors.
- Up to 2 MB per response, bounded parsing/diff work and a 30-second overall fetch deadline per page.
- 256 MB memory and a 240-second application deadline. Split long or slow URL lists into smaller monitors.
- Robots rules are respected. Compression and conditional requests are used when the source supports them.

No JavaScript rendering, logged-in pages, proxies, CAPTCHA bypass, screenshots, automatic alerts, AI interpretation or product-variant matching. Do not include access tokens or other secrets in URLs. Source-site changes and blocking can cause errors. Neither change importance nor commercial accuracy is guaranteed.

For reproducible problems, open an issue on this Actor with a public example URL, selector and run reference. Never include credentials or private page content in a public issue.

# Actor input Schema

## `urls` (type: `array`):

One to 100 public HTML page URLs. Pages are checked once; links are not followed.

## `monitorName` (type: `string`):

Reuse this name across runs to preserve history. Lowercase letters, digits and hyphens; 1–50 characters. Do not run the same monitor concurrently.

## `selector` (type: `string`):

One simple tag, #id or .class, for example main or #pricing. Empty means all static body text.

## Actor input object example

```json
{
  "urls": [
    "https://example.com/"
  ],
  "monitorName": "my-pricing-monitor",
  "selector": ""
}
```

# Actor output Schema

## `checks` (type: `string`):

One row per completed check, including free error results. Changes include text evidence.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "urls": [
        "https://example.com/"
    ],
    "monitorName": "my-pricing-monitor"
};

// Run the Actor and wait for it to finish
const run = await client.actor("futurescash/price-terms-change-evidence").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "urls": ["https://example.com/"],
    "monitorName": "my-pricing-monitor",
}

# Run the Actor and wait for it to finish
run = client.actor("futurescash/price-terms-change-evidence").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "urls": [
    "https://example.com/"
  ],
  "monitorName": "my-pricing-monitor"
}' |
apify call futurescash/price-terms-change-evidence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,futurescash/price-terms-change-evidence"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/UCIxKQ0L7HcZxHsqV/builds/wGlhnxgNqeHS7uLrL/openapi.json