Perplexity launches Monitor API for web and page tracking at $1 per 1,000 runs

Perplexity has released the Monitor API, a developer service that checks the web or a list of known pages on a schedule and sends a signed webhook when it finds an update that fits a stated goal. The company announced the product on November 16, 2026, and it is available immediately through the Perplexity API and the API Console, using the same API key that developers already use for the Search, Context and Agent APIs.
Pricing is set per check rather than per token. A Search monitor costs $1 per 1,000 succeeded runs, and a Page monitor costs $1 per 1,000 fetched URLs, according to the official API pricing page. Failed and skipped runs are free, and a succeeded Search run is billed once even when it performs more than one search internally.
The service runs in two modes. A Search monitor sends one query through Perplexity Search across web and news results and keeps new, relevant findings, while a Page monitor watches between 1 and 10 specific URLs, such as pricing pages, changelogs or policy pages, and returns a text diff when something meaningful changes. Every candidate result is screened by Perplexity Decider, the company's judging model, before a webhook is sent, and each update carries a confidence score between 0 and 1.
Schedules range from every minute to every 31 days, either as a fixed interval or as a five-field cron expression with a time zone, and each API organization can keep between 100 and 500 monitors active depending on its usage tier.
··········
HOW THE PERPLEXITY MONITOR API WORKS.
A monitor is defined by a name, its targets, a schedule and, optionally, a goal written in plain language. Creating one makes the first run due immediately; later runs follow the schedule until the monitor is paused or deleted. Each run continues from the point where the previous successful run ended, which lets the service separate new material from items it has already reported.
For a Search monitor, the documentation describes a run window that starts at the previous successful run and ends when the current run starts. Before the first successful run, the window opens one schedule period before the monitor was created, up to a maximum of seven days back. Results are deduplicated by normalized URL, both inside a run and against URLs seen earlier, and that seen-URL state is retained for 90 days. Changing the goal does not replay URLs that were already seen.
For a Page monitor, the first successful fetch of each URL saves a baseline and reports no change. Each later run compares the newly fetched text with the saved version, and differences that pass the relevance check are returned as a `page_change` entry with a unified diff, counts of added and removed lines, the confidence score and the timestamps of both fetches. The diff is capped at 24 KiB. Because the comparison is between fetched snapshots, edits made and reverted between two runs never appear.
Results are stored and readable through the API, and run history is kept for 90 days. A run can succeed while still listing individual errors per target, such as a blocked page or a timeout, and a Page run counts as succeeded when at least one of its URLs was fetched.
··········
PERPLEXITY DECIDER AS THE RELEVANCE FILTER FOR MONITORS.
The quality gate is Perplexity Decider, the judging model Perplexity released earlier in November as a separate API product and which we covered in our article on Perplexity Decider v1.3 and its $0.02 per 1M token pricing. In the Monitor API, Decider evaluates every web result against four checks described by the company: relevance to the goal, legitimacy of the source, whether the result adds new information, and freshness within the run window. Page changes are judged on whether they are meaningful for the goal; without a goal, they are judged for general meaningfulness.
Perplexity says an update is delivered only when every check meets its threshold, and that thresholds can be adjusted per check. The current API reference for creating a monitor documents the `goal` field (up to 2,000 characters) as the relevance control and does not yet list separate threshold fields, so developers should treat the goal as the documented lever for now. The goal can be edited without recreating the monitor.
Decider's judging is included in the Monitor price. The pricing page lists the Decisions API separately, at $0.02 per 1M input tokens for `pplx-decider-v1.3`, for developers who call the judge directly in their own pipelines.
··········
PERPLEXITY MONITOR API PRICING, LIMITS AND SCHEDULES.
The official figures below come from Perplexity's API pricing page and the Monitor API reference, as listed on November 16, 2026.
........
Item | Official value |
Search monitor | $1 per 1,000 succeeded runs ($0.001 per run) |
Page monitor | $1 per 1,000 fetched URLs ($0.001 per URL) |
Failed or skipped runs | Not billed |
Targets per monitor | 1 Search target, or 1 to 10 Page targets |
Results per Search run | Up to 20 (default 20) |
Interval schedule | From 1 minute to 31 days, up to 10% jitter |
Cron schedule | Five fields, IANA time zone, up to 10 minutes jitter |
Run history | 90 days |
Zero data retention orgs | Cannot create or run monitors (HTTP 403) |
........
Active-monitor limits apply per API organization, and paused monitors do not count toward them. The tiers follow Perplexity's existing usage tiers, which are based on cumulative credit purchases.
........
Usage tier | Credits purchased | Active monitors |
Tier 0 | $0 | 100 |
Tier 1 | $50+ | 100 |
Tier 2 | $250+ | 200 |
Tier 3 | $500+ | 300 |
Tier 4 | $1,000+ | 400 |
Tier 5 | $5,000+ | 500 |
........
Creating or resuming a monitor at the limit returns HTTP 409 with `quota_exceeded`. Search targets accept up to 20 included and 20 excluded domains, a freshness filter that selects newly published pages, recently updated pages or both, and a query of up to 1,000 characters. Monitors can also carry up to 16 metadata key-value pairs that are echoed on every webhook, which lets an application route an update to the right user, workspace or agent.
··········
WHAT A PERPLEXITY MONITOR COSTS PER MONTH.
Because billing is per run or per fetched URL, the monthly bill depends almost entirely on frequency. The examples below assume a 30-day month and that every run succeeds; failed and skipped runs would lower the totals.
........
Monitor setup | Billed units per month | Monthly cost |
1 Search monitor, daily | 30 runs | $0.03 |
1 Search monitor, hourly | 720 runs | $0.72 |
1 Search monitor, every 15 minutes | 2,880 runs | $2.88 |
1 Search monitor, every minute | 43,200 runs | $43.20 |
1 Page monitor with 10 URLs, daily | 300 URLs | $0.30 |
1 Page monitor with 10 URLs, hourly | 7,200 URLs | $7.20 |
1 Page monitor with 10 URLs, every 15 minutes | 28,800 URLs | $28.80 |
100 Search monitors, hourly | 72,000 runs | $72.00 |
........
The comparison with Perplexity's own Search API is instructive. A team that polled 100 queries every hour through the standard Search API would make 72,000 requests a month, which at the listed $5 per 1,000 requests comes to $360, or $72 with Fast Search at $1 per 1,000. The Monitor API charges the same $72 as Fast Search for that volume while adding deduplication, the run-window logic, Decider judging and webhook delivery, which the team would otherwise have to build and pay for separately.
Page monitoring is where costs grow fastest, since every URL counts on every run. At the Tier 5 ceiling of 500 active monitors, each watching 10 pages hourly, an organization would fetch 3.6 million URLs a month and pay $3,600. Choosing a daily schedule for pages that rarely change, such as terms of service, cuts that figure by a factor of 24.
··········
WHAT CHANGES FOR DEVELOPERS USING THE PERPLEXITY API.
Developers who already hold a Perplexity API key need no new account or contract; monitors are created with a `POST` request to `https://api.perplexity.ai/v1/monitors` or from the API Console, and billing draws on the same credits. The documentation's minimal Search monitor example looks like this:
curl --request POST https://api.perplexity.ai/v1/monitors \
--header "Authorization: Bearer $PERPLEXITY_API_KEY" \
--header "Content-Type: application/json" \
--data '{
"name": "AI research and product news",
"targets": [
{
"type": "search",
"query": "AI product launches and research news",
"max_results": 3
}
],
"schedule": {"type": "interval", "interval": "1w"}
}' | jqWebhooks are optional but are the intended delivery path. Payloads follow the Standard Webhooks v1 format and are signed with HMAC-SHA256; failed deliveries are retried seven times over roughly 17.6 hours. By default a monitor sends `monitor.changes.detected` and `monitor.paused` events, and `monitor.run.completed` must be requested explicitly. Monitors can pause themselves for reasons that include a failing webhook, failing sources, insufficient credits or an organization policy, so the pause event is the one that protects against silent gaps in coverage.
Perplexity positions the product for go-to-market automation (funding rounds, executive hires and launches that trigger account research), equity research (earnings, guidance changes and adverse media), competitive intelligence on rivals' pricing pages and changelogs, and regulatory monitoring routed to compliance teams. Organizations under a zero data retention agreement are excluded for now: their requests to create, resume or run monitors return HTTP 403. For a wider view of the developer platform, see our overview of Perplexity API access and developer use cases, and for the Agent API's recent price change, our report on the Perplexity Agent API ultra effort cost cut.
··········
PERPLEXITY MONITOR API: CONFIRMED DETAILS AND OPEN POINTS.
The documented facts are clear. The Monitor API is generally available, prices Search monitors at $1 per 1,000 succeeded runs and Page monitors at $1 per 1,000 fetched URLs, supports schedules from one minute to 31 days, caps active monitors at 100 to 500 per organization by tier, and delivers signed webhooks with retries. Decider judging and deduplication are part of the run price.
Some points rest on Perplexity's own description. The company says it tested Monitor against Search API providers across 60 topics drawn from production queries, running each monitor for eight hours and scoring relevance and publication timing with a separate model, and claims it delivered the most fresh, relevant results across the widest range of topics. It has not named the competing providers or published per-topic scores, so the claim cannot be checked independently. The per-check thresholds described in the announcement are also absent from the current API reference.
For teams that already poll search APIs on a timer, the arithmetic favors switching: at hourly frequency the Monitor API costs the same as Fast Search requests while removing the deduplication and filtering work. The cost risk sits in high-frequency Page monitors across many URLs, where the per-URL meter adds up quickly and the schedule is the main control.
··········
FOLLOW US FOR MORE.
·····
DATA STUDIOS
·····
datastudios.org




