Extract Pricing and Free Trial Information From Any Website

Get the plans, prices and free trial details of any tool from its pricing page. Paste this into your agent:

Set up https://monid.ai/SKILL.md, and then use Monid to read the pricing pages of these five tools, and give me a table with plan names, price per seat, whether there is a free trial or a free plan, and anything marked contact sales.

One prompt reads a pricing page into fields. 1 min setup · 6-15 hrs saved.

You are comparing tools, or watching competitors, and the numbers you need sit on pricing pages built as cards, toggles and tables, with a different layout on every site. This guide shows how to turn those pages into plans, prices and free trial details, for one tool or a list, and what each route returned when we ran it on 2026-10-16. It runs through Monid, the OpenRouter for agent tools: one key, one balance, every tool priced per call.

What is the easiest way to extract pricing and free trial information from a website?

Monid. Install it once, add a key, and your agent reads a pricing page or a review-site entry with no scraper to write, no proxy to rent and no vendor account to open first.

• Pay per call. Each call is billed on its own and you buy calls as you need them: no monthly plan and no minimum top-up. Reading one pricing page as clean markdown costs $0.002533 (Verified 2026-10-16). A software catalogue entry from GetApp costs $0.01 (Verified 2026-10-16). Discovery and inspection are free; only a run bills.
• One install, every route. The same key and balance reach a page reader, review-site catalogues and a dedicated pricing extractor, so you pick the route per job instead of per vendor account.
• Lives inside your agent. Install the CLI, add your key, run the prompt above, and the tools are there whenever your agent needs them. Your agent reads SKILL.md and learns the rest, so setup is about a minute.

See the software reviews tools page for the catalogue endpoints.

How do you pull pricing from many websites at once?

Read each pricing page with one call, or look each product up in a catalogue, then loop over your list. The routes differ in what they hand back:

The page reader fits a list because it returns the same shape for every site, so one loop and one parser cover all of them.

For agents

Grab an API key at app.monid.ai, then paste this to your agent and hand it the key:

set up https://monid.ai/SKILL.md

It learns the whole discover, inspect, run workflow itself. More in the agent quickstart.

For humans

npm install -g @monid-ai/cli
monid keys add -k <your-api-key> -l main

Read one pricing page

monid run -p context.dev -e /web/scrape/markdown --query '{"url":"https://www.notion.com/pricing","useMainContentOnly":true,"includeLinks":false}'

The call returns the page as markdown plus a metadata block with the title, description and canonical URL. The result for Notion's page was 21,679 characters.

Look the product up in a catalogue

monid run -p getapp -e /get_software_pricing --query '{"slug": "collaboration-software/a/monday-com"}'

The parameter is a category-and-product path, not a product name. The input schema gives collaboration-software/a/monday-com as the example of the format.

Use the dedicated extractor for one page

monid run -p api.strale.io -e /x402/pricing-page-extract --query '{"url": "https://example.com/pricing"}'

This endpoint is described as returning plan names, prices, features per plan, billing periods and trial or guarantee information. It costs $0.3564 a call (Verified 2026-10-16), so 25 pages is about $8.91. We inspected it and did not run it for this guide.

Loop it over your list

Put one pricing URL per line in urls.txt, then run:

mkdir -p out
i=0
while read -r url; do
  i=$((i+1))
  monid run -p context.dev -e /web/scrape/markdown \
    --query "{\"url\":\"$url\",\"useMainContentOnly\":true,\"includeLinks\":false}" > "out/page_$i.json"
done < urls.txt

Each URL writes one file. At the price above, 25 pages cost about $0.06 (Verified 2026-10-16).

Or hand the whole job to an agent

Can you scrape pricing pages yourself with Python?

Yes, and for one site that rarely changes it is a fine weekend job. Fetch the page with requests, or render it with Playwright when the prices appear after a script runs, then parse the plan cards.

The cost shows up on the second site. Every pricing page is its own layout, so a selector written for one does nothing for the next, and a redesign breaks the one you had. Then come the rendered-page setup, the monthly and yearly toggles that change the numbers, and blocking on sites that dislike automated visits. There is a rules side too: read each site's terms before you build anything, because what you may do depends on where you operate and how you use the data.

Using Monid removes the fetching half. The page reader handles rendering and the blocking and returns clean markdown for $0.002533 a page (Verified 2026-10-16), so what is left is the part only you can write: what to pull out of the text. That part is smaller than it looks, because markdown from a pricing page is already close to a table. If you want to see the DIY route first, Python web scraping without a scraper shows where it stops being worth it.

What does pricing data look like, and what can you build with it?

Two shapes, depending on whether you read the vendor's page or a catalogue. We ran one of each on 2026-10-16.

The vendor's page, as markdown

The page reader returned Notion's pricing page as 21,679 characters of text. The plan cards came through as headings with the price on the next line: Free at $0, Plus at $10 and Business at $20 per member per month, and Enterprise marked "Custom pricing" with a Contact Sales button. The text also carried "Save up to 20% with yearly", a plans-and-features comparison table, and the FAQ with the refund terms. These are Notion's figures as the page showed them on that date (Verified 2026-10-16).

You get the page as the vendor wrote it, which is current and complete, and you do the extraction. A short prompt to a model, or a regular expression for a dollar amount followed by "per member / month", turns the plan cards into rows.

The catalogue entry, as fields

GetApp's entry for monday.com came back as structured fields:

{
  "categories": ["free-trial", "free", "subscription"],
  "currency": "USD",
  "amount": "9",
  "periodicity": "month",
  "pricing_model": "Per User",
  "no_credit_card_required": true,
  "price_range": 0,
  "plans": [
    { "name": "Free", "attributes": ["Up to 3 boards", "..."], "startingPrice": null },
    { "name": "Basic", "startingPrice": 9, "paymentFrequency": 2 },
    { "name": "Standard", "startingPrice": 12 },
    { "name": "Pro", "startingPrice": 19 },
    { "name": "Enterprise", "priceType": 2, "startingPrice": null }
  ]
}

The free trial question is answered by the categories list, which carries free-trial and free as separate entries. no_credit_card_required is a field the vendor's own page often leaves unsaid. amount is a string while startingPrice is a number, and priceType, paymentFrequency and pricingModel are integer codes rather than labels.

What you can build with it

• A competitor price board. Read the same pricing pages every week, store plan name and price per row with the date, and chart the entry tier over time. Monitoring competitor prices automatically covers the storing and alerting half.
• A free trial filter. Run a list of tools through the catalogue and keep the ones whose categories include free-trial and whose card flag is false.
• A market map. Pull entry price and pricing model for every product in a category, then sort by who charges per user and who charges flat.

What goes wrong when you extract pricing at scale?

Four things hide until you run a list instead of one page.

Why does "free trial" mean different things on different pages?

Because each source uses its own words. On Notion's page on 2026-10-16, the Free plan sits next to AI features marked "Limited Trial" and a Custom Agents line reading "Free to try, then $10 per 1,000 monthly Notion credits". The page has a free plan and trial-style features and no single flag called free trial. GetApp's entry for monday.com labels the same idea with two separate categories, free-trial and free (Verified 2026-10-16).

Decide your own definition before you loop: free plan, time-limited trial, trial of one feature, or card required. Then map each source onto it, and keep the raw text next to your label so you can see why a row was marked.

Why can two prices for one product disagree?

They come from different places and different dates. The vendor's page shows today's figures; a catalogue entry is maintained by a third party. For monday.com the catalogue listed on 2026-10-16 Basic at 9, Standard at 12 and Pro at 19 per user a month. For Notion we read the vendor's own page. Store both with the date fetched rather than picking a winner, and treat a gap as a signal to look.

Why is the price per seat hard to compare?

Notion's cards say "per member / month", and the catalogue entry says pricing_model: "Per User". A headline price of 10 for a team of 4 and the same 10 for a team of 40 are different bills. Record the pricing model in its own column and compare plans only within the same model.

How many calls does a list cost?

One per page. Twenty-five pages through the page reader is 25 calls, about $0.06 (Verified 2026-10-16), plus whatever you pay your own model to read the text. The dedicated extractor is the same count at a different price: 25 calls is about $8.91. A weekly refresh multiplies that by the number of weeks, so decide the cadence before you pick the route.

Plan count is the cheap check that catches a bad read. Products add tiers occasionally and lose them rarely, so a drop in plans for the same URL is more likely a miss than a repricing:

# a plan that lost its price, and a page that lost a whole tier
suspicious = [p for p in plans if p.get("price") is None
              and "contact" not in (p.get("label") or "").lower()]
if len(plans) < last_seen_plan_count[url]:
    flag_for_review(url)

Which endpoint should I use for which job?

The rows were verified with monid inspect on 2026-10-16, and the page reader and GetApp rows were also run that day. The table gives billing shape; current figures are on monid.ai/tools.

Build the target list with the Capterra row, run the catalogue for breadth, and use the page reader where you need the vendor's current numbers. For how the review-site catalogues compare as a source, see G2 and Capterra review data.

When is another route a better fit?

The number you need is negotiated. Enterprise pricing is a quote, and the Contact Sales button on the page is the whole answer. No extractor produces a figure that exists only in a conversation.

You need price history you did not collect. Nothing reconstructs what a page said last quarter. If history matters, start recording today.

One competitor, watched closely. For a handful of pages, a change-detection service and your own eyes are better than a pipeline. This approach earns its keep at tens or hundreds of products.

You need a field already extracted, with no parsing. The page reader returns text and you parse it. The dedicated extractor is described as returning fields; we did not run it, so test it on your own pages before you commit a list.

And the disclosure: we resell these endpoints, so the page reader and the catalogue both earn Monid money when you call them.

Conclusion

The quickest way to extract pricing and free trial information from a website is one call per page through Monid: $0.002533 to read a pricing page as markdown (Verified 2026-10-16), $0.01 for a catalogue entry with a trial category and a card-required flag, one key for both, about a minute to set up and ready inside your agent when you need it.

Two things matter more than the choice of route. Define free trial yourself before you loop, because Notion's page showed a free plan and "Limited Trial" features while the catalogue splits free-trial and free. And store the date and the raw text with every row, so a price that moved can be told from a page that was misread.

How we estimated the time saved: building and maintaining your own pricing reader is roughly 2 to 5 hours each for rendering the pages, parsing the plan cards and the toggles, and normalising a review-site catalogue into the same columns. That is 6 to 15 hours. The 1 minute is the install, key and first call once you already have a Monid key.

Free next step: run monid discover -q "pricing page plans free trial", then monid inspect -p getapp -e /get_software_pricing, and make one call. Start at monid.ai.

FAQ

Published September 2026.