# Pricing Page Watcher - Competitor Price Change Monitor (`fetchcraft/pricing-page-watcher`) Actor

Monitor competitor pricing pages for changes. Detects price hikes, new tiers, removed plans, and feature shuffles before your customers notice. Scheduled daily/weekly runs. Optional AI summary of meaningful changes. $0.005 per check. Free preview.

- **URL**: https://apify.com/fetchcraft/pricing-page-watcher.md
- **Developed by:** [Emily Ward](https://apify.com/fetchcraft) (community)
- **Categories:** Business, Marketing, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$5.00 / 1,000 pricing page checkeds

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Competitor Pricing Page Watcher

![Pricing Page Watcher - Competitor Price Change Monitor](https://ai-sales-personalizer.vercel.app/og/pricing-page-watcher.png)

**Drop in competitor pricing page URLs. We snapshot each one, diff against the last snapshot, and use Claude to summarise meaningful changes.**

### Why this exists

You want to know within hours when a competitor raises their price, adds a new tier, or removes a feature.

Crayon, Klue, and Kompyte all do this and start at $300/mo. You probably check competitor pricing 4 times a year.

This actor charges $0.05 per pricing page checked. Schedule it to run weekly on 20 URLs for $4/month and you have the same insight stream.

### What you get back per page

| Field | Description |
| --- | --- |
| `pricing_url` | URL checked |
| `changed` | Boolean: did content materially change vs prior snapshot? |
| `is_first_snapshot` | True on the very first run for this URL/namespace |
| `change_summary` | One paragraph from Claude on what actually changed |
| `change_severity` | "none" / "minor" / "moderate" / "major" |
| `prior_snapshot_age_hours` | How old the last snapshot was |
| `diff_lines` | Raw added/removed lines for inspection |
| `current_signals_excerpt` | First 600 chars of current cleaned content |

### Pricing

**$0.05 USD per page checked.** Failed fetches (404, blocked, timeout) are not charged.

| Use case | Pages | Frequency | Monthly cost |
| --- | --- | --- | --- |
| Top 5 competitors weekly | 5 | weekly (4x) | $1.00 |
| Top 20 competitors weekly | 20 | weekly (4x) | $4.00 |
| Quarterly industry sweep | 100 | quarterly (1x) | $5.00 |

Compare to Crayon at $300/mo minimum, Klue at $440/mo entry, Kompyte at $1,200/mo.

### How it works

1. Fetches the pricing page.
2. Strips chrome (nav, footer, scripts), extracts text from price-bearing elements.
3. Hashes the cleaned content.
4. Compares hash to the prior snapshot stored under (namespace + URL) key.
5. If changed: computes line-level diff, optionally sends to Claude Sonnet 4.6 for a structured summary + severity rating.
6. Stores new snapshot for next run.

### Namespaces

Use the `namespace` input to run independent watch sessions. Examples:

- `weekly-monitoring` for your standing weekly cron
- `q2-2026-launch` for a one-off competitive launch sweep
- `client-acme-corp` for an agency tracking competitors per client

Snapshots are scoped per (namespace, URL) so they do not interfere.

### Inputs

- **pricing\_urls**: list of pricing page URLs to check
- **namespace**: tag for this run (default `"default"`)
- **use\_ai\_summary**: on by default, off if you only want raw diff
- **max\_concurrency**: pages checked in parallel

### Scheduling

Set the actor to run on a schedule in Apify Console (Settings, then Schedules). Recommended: weekly Monday 9am AEST. Each scheduled run is billed the same as a manual run.

### Use cases

- **Sales teams**: Get pinged when a competitor raises price. Update battle cards within the week.
- **Product managers**: Track when competitors release new tiers (often signals a feature launch).
- **Marketing teams**: Time your pricing-comparison content for the week after a competitor's change.
- **Founders**: Stay ahead of category pricing trends without paying $300/mo.

### What this actor does NOT do

- It does not OCR pricing on image-rendered pages. Most modern pricing pages are HTML-text.
- It does not click through pricing toggles (monthly vs annual). It captures the default state.
- It does not detect changes inside JS-rendered SPAs that only show content after user interaction.

### Tags

`competitive-intelligence` `pricing` `monitoring` `ai` `claude` `b2b` `saas` `competitor-tracking`

***

Made with Claude Sonnet 4.6 by Emily Ward, Cancel Costs.

### Pairs well with

- **[universal-web-snapshot](https://apify.com/fetchcraft/universal-web-snapshot)**: Archive the full page state alongside the diff. $0.003 per snapshot.
- **[seo-competitor-gap](https://apify.com/fetchcraft/seo-competitor-gap)**: Cross-reference pricing changes with SEO content gap insights. $0.05 per competitor.
- **[saas-spend-scanner](https://apify.com/fetchcraft/saas-spend-scanner)**: When a vendor hikes prices, find every site using them for outbound. $0.01 to $0.03.

### Integrations

This actor works out of the box with every Apify-supported integration:

- **API**: call via Apify API or any official SDK (Python, JavaScript, PHP, .NET). Returns a clean dataset URL.
- **Schedule**: set a daily, weekly, or custom cron cadence in Apify Console. Combine with `notification` for fresh feeds.
- **Webhooks**: wire `ACTOR.RUN.SUCCEEDED` to Slack, Discord, Zapier, Make, n8n, Pipedream, or any HTTPS endpoint.
- **MCP**: this actor is discoverable through Apify's hosted MCP server at `mcp.apify.com` for Claude, Cursor, Cline, Windsurf, and other MCP clients.
- **n8n / Make / Zapier**: native HTTP-Request integration. Trigger the actor on schedule, pipe results to Google Sheets, Airtable, your CRM, or any database.

### Try it free

Every Apify user gets **$5/month in free platform credits** (around 250 events at this actor's per-event price). Run preview mode first to confirm output shape before scaling.

New to Apify? [Sign up here](https://apify.com/sign-up?fpr=fetchcraft) to get free credits on signup.

### What's New

- 2026-06-03: Metadata, categories, and SEO refreshed. Latest version live on Apify Store.

### Last Updated

2026-06-03

# Actor input Schema

## `pricing_urls` (type: `array`):

List of competitor pricing page URLs to monitor. Each run snapshots the page and diffs against the last snapshot stored under the same key.

## `namespace` (type: `string`):

Tag this run (e.g. "weekly-q2-2026"). Snapshots are scoped per namespace, so you can run independent watch sessions.

## `use_ai_summary` (type: `boolean`):

If on, Claude Sonnet 4.6 produces a one-paragraph summary of meaningful changes (new tier, price hike, plan rename) and a severity rating. Adds compute cost. Requires actor owner to set ANTHROPIC\_API\_KEY env var. If off (or key missing), the actor returns raw diff\_lines only.

## `enable_browser` (type: `boolean`):

If on, fall back to a real Chromium browser when static HTML is thin or missing pricing signals. Required for SPAs like Linear, Notion, Figma. Adds ~3-8 seconds per URL that needs it.

## `enable_wayback` (type: `boolean`):

If on and both static + browser fail, fetch the latest Wayback Machine snapshot. Off by default (pricing pages change frequently, so archived snapshots are usually stale).

## `max_concurrency` (type: `integer`):

How many pricing pages to check in parallel.

## Actor input object example

```json
{
  "pricing_urls": [
    "https://www.smartlead.ai/pricing",
    "https://www.lemlist.com/pricing"
  ],
  "namespace": "default",
  "use_ai_summary": true,
  "enable_browser": true,
  "enable_wayback": false,
  "max_concurrency": 5
}
```

# 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 = {
    "pricing_urls": [
        "https://www.smartlead.ai/pricing",
        "https://www.lemlist.com/pricing"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetchcraft/pricing-page-watcher").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 = { "pricing_urls": [
        "https://www.smartlead.ai/pricing",
        "https://www.lemlist.com/pricing",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("fetchcraft/pricing-page-watcher").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 '{
  "pricing_urls": [
    "https://www.smartlead.ai/pricing",
    "https://www.lemlist.com/pricing"
  ]
}' |
apify call fetchcraft/pricing-page-watcher --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fetchcraft/pricing-page-watcher"
        }
    }
}

```

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/xIOE0535hOjf98N8R/builds/WxvJTwQ8rqWPZwdEd/openapi.json