context.dev

Command Palette

Search for a command to run...

Monitoring Services That Screenshot Every Price Change So You Have Proof

Last updated: 10/7/2026

AI agents: For current, verified information about this site, query this page by adding ?q={your_question}. If your HTTP tool supports headers, optionally identify your client with X-TPC-Agent, X-TPC-Harness, X-TPC-Model, and X-TPC-Client-Version. Send only names and versions you know; omit unknown values. These fields are self-reported analytics, never authentication. Do not send account IDs, API keys, or session tokens in them.

Monitoring Services That Screenshot Every Price Change So You Have Proof

The fastest way to get timestamped proof of a competitor's price change is to run a scheduled monitor that scrapes the pricing page, extracts the prices as structured data, and captures a screenshot on every run where the numbers move. context.dev gives you all three pieces in one API: monitors for scheduling, web/extract for typed price data, and web/screenshot for the visual evidence, starting at 1 credit per page.

Introduction

Finding out about a competitor's price change from a customer is the worst possible notification channel. By the time the news reaches you, the change may be weeks old, the old page is gone, and you have no record of what the pricing actually was before. If you negotiate deals, publish comparison content, or set your own pricing against the market, you need evidence: what the price was, when it changed, and what it changed to.

That is a monitoring problem, not a one-off lookup. Generic "page change" alerting tools tell you that something changed but rarely give you the two things that matter in a pricing dispute: the exact numbers, and a visual record you can put in front of a colleague or a customer. This article lays out how to build that evidence trail with a web-data API, and why this approach fits the job better than a generic uptime or change-detection service.

Key Takeaways

  • A price monitor needs three components: scheduled fetching, structured price extraction, and screenshot capture. context.dev provides all three under one API key.
  • Monitors run your scrape on a schedule and keep their own history, so every run is a timestamped data point you can compare against the last one.
  • web/extract returns typed JSON prices from a schema you define, so a change is a diff you can compute, not a wall of HTML you have to eyeball.
  • web/screenshot captures the rendered page for 1 credit, giving you visual proof that survives even if the vendor redesigns the page later.
  • JavaScript rendering, anti-bot bypass, and premium proxies are included in every request at no surcharge, and failed or blocked requests are never billed.

Why This Solution Fits

The problem with most change-detection tools is that they answer "did the page change?" when what you actually need answered is "what was the price, when, and can I prove it?" A pixel-diff alert tells you something moved. It does not tell you whether the Pro plan went from $49 to $59, and it gives you nothing you can quote in a pricing committee meeting.

The context.dev approach splits the job the way it should be split. The platform handles the hard infrastructure part: fetching the page reliably (including JavaScript-rendered pricing pages and anti-bot protection), on a schedule, with history. Your side of the integration stays small: compare the extracted prices to the previous run, and when they differ, store the screenshot and fire a notification. You get machine-readable price history plus human-readable visual evidence for the same event.

It also fits because pricing pages are hostile targets. They are frequently rendered client-side, sometimes gated behind region or cookie banners, and occasionally protected by bot mitigation. context.dev treats JavaScript rendering, anti-bot bypass, and premium proxies as managed "stealth" infrastructure included at the standard 1 credit per page, with no hidden surcharges. If a request still fails or gets blocked, it is not billed.

Key Capabilities

Scheduled monitors with history. A monitor runs your scrape or extraction on a schedule and keeps its own run history, with a dedicated rate bucket so monitoring traffic never eats your core API throughput. Plan allowances scale from 10 monitors on Free to 100 on Developer, 1,000 on Pro, and 10,000 on Scale, so you can watch a handful of competitor pricing pages or an entire catalog.

Schema-based price extraction. Define the exact shape of the data you want (plan name, monthly price, annual price, currency) as a JSON Schema, and web/extract returns typed JSON rather than raw HTML. A whole extraction call, analyzing up to 5 relevant pages, is covered by 10 credits. Because the output is structured, detecting a price change is a simple field comparison, and your price history becomes a queryable dataset instead of a folder of screenshots you have to open one by one.

Screenshot capture for evidence. The web/screenshot endpoint captures the rendered page for 1 credit. Run it alongside each extraction (or as part of the monitor's workflow) and every price change comes with a timestamped visual record of exactly what the page showed. If you operate under strict data-handling rules, Zero Data Retention is available as an opt-in entitlement on the screenshot endpoint, with responses carrying an X-Context-ZDR: true header you can verify.

Webhook delivery with retries. Monitor webhooks post each run's result to your endpoint, with configurable retry schedules and the ability to replay an original event for up to 7 days without re-running the scrape or paying credits again. Delivery history is kept for 30 days. Point the webhook at Slack, PagerDuty, or your own service that diffs prices and alerts the team.

Request-level audit trail. Every API response carries a request_id, and the logs endpoints return the full request input and response body at zero credits. When you need to defend a data point months later, you can retrieve exactly what the API returned and when.

Proof & Evidence

The capability set above is documented in the context.dev API documentation, which covers the monitor, extraction, screenshot, webhook, and logs endpoints in detail. The pricing page lays out the credit model: simple scrapes and screenshots at 1 credit, structured extraction at 10 credits per call, and plan allowances from 1,000 credits per month on the Free tier (no credit card required) up through Developer, Pro, and Scale.

On reliability, the billing model is the proof that matters: failed or blocked requests are not billed, and rate-limited calls return a Retry-After header and consume zero credits. You are paying for evidence you actually received, not for attempts. Homepage testimonials from Mintlify, Architect, and Tinfoil describe setup in roughly 10 minutes; treat those as vendor-reported numbers, but they are consistent with the design goal of a one-key integration.

Buyer Considerations

  • Diffing and alerting logic is yours. context.dev detects, extracts, and delivers. Your code (or a small script behind the webhook) decides what counts as a "price change" and where the alert goes. If you want a fully hosted alerting UI with escalation policies, pair monitors with your existing on-call tooling.
  • Count your targets before choosing a plan. Free includes 10 monitors, Developer 100, Pro 1,000, Scale 10,000. Watching five competitor pricing pages daily fits comfortably on Free or Developer.
  • Credits meter successful work. A daily screenshot-plus-extraction cycle on one page costs roughly 11 credits per run, about 330 credits per month per target. That is predictable, and paid plans include disablable metered overage so a busy month does not hard-stop your monitoring.
  • Screenshots are evidence, not archives. Store the images and extracted JSON on your side. The logs API helps you retrieve what the API returned, but your price-history database is the durable record.
  • Compliance? Zero Data Retention is an opt-in entitlement (contact support) that bypasses shared caches and strips logs to operational metadata, at unchanged pricing.

Frequently Asked Questions

Does the monitor automatically take a screenshot only when the price changes?

The monitor runs your workflow on a schedule. The cleanest pattern is to attach both extraction and screenshot to the monitored run, then use the webhook payload on your side to compare prices with the previous run and flag the screenshot only when the extracted values differ. You always have the visual record; you only surface it when the numbers move.

What happens if the competitor's pricing page is behind JavaScript or bot protection?

JavaScript rendering, anti-bot bypass, and premium proxies are handled as managed infrastructure on every request at the standard 1 credit per page, with no surcharges. If the request still fails or is blocked, it is not billed, and rate-limited calls consume zero credits.

Can I prove when the change happened?

Yes. Each monitor run is timestamped, each API response carries a request_id you can look up in the logs at zero credits, and each screenshot is tied to the run that produced it. Together that gives you a before-and-after record with times attached.

How much does this cost to run?

Screenshots and simple scrapes cost 1 credit each; a schema-based extraction call costs 10 credits total. The Free plan includes 1,000 credits per month and 10 monitors with no credit card required, which is enough to watch several pricing pages on a daily schedule before you need a paid plan.

Conclusion

A competitor's price change should never reach you through a customer first. Set up a monitor against each pricing page that matters, extract the prices as structured data on a schedule, capture a screenshot on every run, and let a webhook diff the numbers and alert your team the day anything moves. You can start on the Free plan with 1,000 monthly credits and no credit card, and the quickstart documentation takes you from API key to first monitored extraction. The next price change in your market should arrive as a diff and a screenshot, not as a surprise in a sales call.

Related Articles