CleanedWeb

Use case

Price monitoring from competitor and marketplace sites

Track the prices a store or marketplace shows for the products you care about, as records from an API instead of a scraper you maintain. Each call returns price, currency and availability for the products in scope.

The problem

Prices live on product pages, and the pages are built for shoppers, not for programs. A price tracker usually starts as a script that reads a few page elements. It then breaks when the store changes its layout, moves a price into a script tag or adds a sale badge next to the number.

Each competitor and marketplace needs its own version of that script, and each one needs a person to notice when it stops returning the right value. A wrong price that looks plausible is worse than an error, because nothing flags it.

How CleanedWeb solves it

A website becomes an API. You give CleanedWeb the product listing or category page and it does the work of turning it into records you can call.

  1. Discover the fields

    CleanedWeb reads the pages and proposes the fields it finds, such as title, price, currency and availability. You review them and keep the ones you need.

  2. Build the API

    It builds and validates an API for that site, with inputs such as a category or search term and a limit on how many records one call returns.

  3. Get a versioned contract

    The fields and their types are saved as a versioned schema. Your code can pin the version it was written against, so a changed contract shows up as a version conflict and not as a silently different price.

  4. Run it on your schedule

    Call the API from your own scheduler, hourly, daily or whatever your pricing decisions need, and store each response with its run details to compare prices over time.

  5. Repairs when the site changes

    When a site changes its layout, CleanedWeb rebuilds the API for it. A rebuild that would remove or retype a field is not swapped in silently. Your own APIs keep their contract until you review a change.

What a record looks like

An illustrative record from a fictional store. The fields of a real API come from the site you choose and are listed on its contract.

{
  "sku": "LAMP-0420",
  "title": "Desk lamp, matte black",
  "price": { "amount": 49.0, "currency": "USD" },
  "list_price": { "amount": 59.0, "currency": "USD" },
  "availability": "in_stock",
  "url": "https://shop.example.com/products/desk-lamp-matte-black",
  "observed_at": "2026-01-15T09:00:00Z"
}

Store each response with the time you observed it. Comparing today's records with yesterday's gives you the price change, and the version of the contract tells you the fields still mean the same thing.

Docs for this use case

Free tools that help

Questions

Which sites can I track?

Any public site whose product pages show the price without a login. Some sites block automated access or require sign-in; those cannot be turned into an API this way. Check a site with the website data checker, then start a build to see what CleanedWeb finds.

How often can I collect prices?

As often as you call the API. CleanedWeb does not run a scheduler for you; you call the API from your own cron job or workflow runner. Set the interval from how fresh the prices need to be and what each run may collect.

What happens when a store redesigns its pages?

A catalog API that keeps failing is rebuilt from the site as it is now, and the rebuild replaces the published version only after it passes checks. For an API you built, a change that would alter its contract waits for your review. See Source changes in the docs. A repair is not guaranteed, so check each run's summary.

Do I get historical prices?

No. Each call returns what the site shows now. To build a price history, store each response with its observation time.

Ready-made APIs in the catalog

These published APIs already return records for this kind of work. Open one to see its fields and a sample record.

Browse the full catalog

More use cases

All use cases

Turn a site into an API

CleanedWeb turns a website into a maintained REST API that returns structured records, with a versioned schema and repairs when the site changes.