Live price monitoring

Track any competitor's prices from the live web, on a schedule.

Point /extract at a pricing page and get back a structured price table, matched to your schema and read from the live page. Run it on a schedule, store the output, and diff it so you catch a price change the day it ships, not the month you notice. You just make the call.

Live web on every call, no stale crawlStructured to a schema you defineRun on a schedule and diff over timegeo_target for region-specific pricing
prices.ts
import Tabstack, { APIError } from '@tabstack/sdk'

const client = new Tabstack()

// Pricing page in, price table out.
try {
  const pricing = await client.extract.json({
    url: 'https://competitor.com/pricing',
    json_schema: {
      type: 'object',
      properties: {
        currency: { type: 'string' },
        plans: {
          type: 'array',
          items: {
            type: 'object',
            properties: {
              name: { type: 'string' },
              monthly_price: { type: 'number' },
              annual_price: { type: 'number' },
              features: { type: 'array' },
            },
          },
        },
      },
    },
    geo_target: { country: 'US' },
    effort: 'standard',
  })

  console.log(pricing) // ready to diff
} catch (err) {
  if (!(err instanceof APIError)) throw err
  console.error(err.status, err.message)
}

The old way

Price tracking means brittle scrapers or a per-site SaaS.

Rolling your own scraper means proxies, headless browsers, and a parser that breaks every time a competitor redesigns. Buying a tool means a monthly bill and a fixed list of sites you are allowed to watch. Both leave you a step behind on the prices you most need to see.

Brittle scrapers

  • Parsers that break on every redesign or JS-heavy page
  • Proxies and headless browsers to run and maintain

Per-site SaaS

  • A monthly bill for a fixed list of sites
  • A pipeline you cannot inspect or extend

/extract/json

Turn any pricing page into a structured price table.

Define the JSON shape you want (plans, prices, billing periods, feature gates) and point /extract at any pricing page. No parsing code, no cleanup on JS-heavy or paywalled layouts. One call returns schema-matched data you can store and compare, with geo_target for region-specific prices.

Features

  • Schema-driven extraction, no parsing code
  • Plans, prices, and feature gates in one call
  • geo_target for region-specific pricing
  • Clean output from JS-heavy pages
prices.ts
TypeScript
import Tabstack, { APIError } from '@tabstack/sdk'

const client = new Tabstack()

// Pricing page in, price table out.
try {
  const pricing = await client.extract.json({
    url: 'https://competitor.com/pricing',
    json_schema: {
      type: 'object',
      properties: {
        currency: { type: 'string' },
        plans: {
          type: 'array',
          items: {
            type: 'object',
            properties: {
              name: { type: 'string' },
              monthly_price: { type: 'number' },
              annual_price: { type: 'number' },
              features: { type: 'array' },
            },
          },
        },
      },
    },
    geo_target: { country: 'US' },
    effort: 'standard',
  })

  console.log(pricing) // ready to diff
} catch (err) {
  if (!(err instanceof APIError)) throw err
  console.error(err.status, err.message)
}
diff.ts
TypeScript
import Tabstack, { APIError } from '@tabstack/sdk'

const client = new Tabstack()

// store and notify are your own storage and alerting.
try {
  // Snapshot as markdown, diff over time.
  const today = await client.extract.markdown({
    url: 'https://competitor.com/pricing',
    effort: 'standard',
  })

  const prev = await store.get('pricing')
  if (today.content !== prev) {
    await store.set('pricing', today.content)
    await notify('Pricing page changed')
  }
} catch (err) {
  if (!(err instanceof APIError)) throw err
  console.error(err.status, err.message)
}

/extract/markdown

Snapshot the whole page to catch every change.

Structured fields catch price moves; a full-page markdown snapshot catches everything else, from a reworded plan name to a quietly dropped feature. Grab the page as clean markdown on a schedule, diff it against the last snapshot, and alert the moment anything shifts.

Features

  • Clean full-page markdown for change tracking
  • Diff over time to catch any edit, not just price
  • Run on a schedule and alert on change
  • effort control over fetch depth

Try it live

Extract a live price table.

Paste any pricing page URL and get a schema-matched price table back from a real /extract/json call. The result is cached in your browser.

Runs a live /extract/json call and returns a schema-matched price table.

Own it vs. buy it

You are renting a tracker for prices that are public.

Pricing pages are public. A monitoring SaaS charges you monthly for a fixed site list and a pipeline you cannot inspect. Build the tracker you actually need on a handful of calls, watch any site you want, and own it.

Monitoring SaaS

  • A monthly seat and a fixed list of watchable sites
  • A pipeline you cannot inspect or extend
  • Alerts on their schedule, not yours

Monthly seat

Build on Tabstack

owned
  • Usage-based credits across five endpoints
  • Watch any site, on the schedule you choose
  • Open every source and verify the price yourself
usage-basedyou own it

Who builds on this

Teams that watch competitor pricing without a SaaS.

Product marketers

How the market is priced, updated on your schedule.

Growth & pricing teams

Know the day a competitor moves, not the month.

Engineers

Price tracking in the product, no scraper to run.

Agents

A live pricing check inside a workflow.

Mozilla-backed

Privacy, Transparency, and Control

When you build on /research, your users' questions and the data behind every answer stay yours. Tabstack is a Mozilla-backed platform, and we handle live-web research responsibly, so you can ship features your users actually trust.

Private by default.Queries and retrieved pages are used to build your answer and support you, then purged. Never sold, never used to train models.

Verifiable by design.Every answer returns source URLs and inline citations, so you and your users can confirm exactly where each claim came from.

Yours to control.You set the mode, scope, and depth of every call. No retained corpus, no lock-in, just clean, cited data you own.

See exactly how we source and handle data in the documentation.

Mozilla Manifesto

Pricing & Plans

All prices in USD.

Free Trial

Every new account includes 10,000 free credits to explore the full platform.

Starter

$10/ month

100,000 credits included

  • Access to all API endpoints
  • Fast research mode
  • Standard rate limits
  • $0.30 / 1k credits overage

For tinkerers & hobbyists who want to simply connect their systems to the internet.

Get Started

Team

$99/ month

500,000 credits included

  • Everything in Starter, plus:
  • Fast + Balanced research modes
  • Increased rate limits
  • $0.30 / 1k credits overage

Low-latency, predictable cost automation so you can focus on your core product.

Get Started

Pro

$499/ month

3,000,000 credits included

  • Everything in Team, plus:
  • Highest rate limits
  • $0.25 / 1k credits overage

For teams deploying and managing production workloads efficiently at scale.

Get Started

Enterprise Plan

Need Custom Pricing?

Custom API quotas, dedicated support, and SLAs for high-volume teams.

Contact Sales

Cost per action

Every endpoint bills in credits. Extract and Generate are a single action per call. Automate and Research run a variable number of actions per task, so cost scales with the work they do.

  • Extract (Markdown)10 credits
  • Extract (JSON)50 credits
  • Generate100 credits
  • Automate100 credits
  • Research (Fast)250 credits
  • Research (Balanced)350 credits

Catch a price change the day it ships.

Start with 10,000 free credits, no card.