Pricing page schema

How to Mark Up SaaS Pricing Plans for Search Engines and AI Assistants

JSON-LD for a SaaS pricing page with one Offer per plan, monthly and annual UnitPriceSpecification, a Rich Results Test check and a prompt test for AI answers.

On this page

Pricing pages change more often than almost any other page on a SaaS site, and they hold the numbers buyers most want an assistant to repeat correctly. The markup that describes the plans fits in one script tag. Most of the effort goes into keeping the plan table, the JSON-LD and every crawler's copy on the same set of numbers.

What schema does for AI answers on a pricing page

Schema markup for LLM parsing of product pricing pages in 2026 has no special AI version. Google's documentation on AI features says "There's also no special schema.org structured data that you need to add" to appear in AI Overviews or AI Mode, and its best practices include "Making sure your structured data matches the visible text on the page." For a pricing page, that second line carries the weight, because the JSON-LD is only as useful as its agreement with the plan table.

Microsoft frames the risk in similar terms. A May 6, 2026 post on the Microsoft Bing Blog about how its index supports AI answers says: "In grounding, a stale fact produces a misleading response." Few facts on a website go stale faster than a price. The markup below aims for one machine-readable statement per plan, matching the page and updated in the same release. Google's structured data policies say even correct markup carries no guarantee of appearing in search results, and none of the assistant documentation we read promises a citation in return for schema.

Picking SoftwareApplication or Product

The official Schema.org documentation for SoftwareApplication handles pricing through an offers property, inherited from CreativeWork, that expects an Offer or a Demand, so subscription plans fit beneath it as Offers. It lists WebApplication and MobileApplication among the more specific types, and WebApplication suits a SaaS product used in the browser. Google's software app documentation supports all three, and its required properties are name, offers.price, and one of aggregateRating or review.

Without ratings or reviews on the page, the software app rich result is out of reach, and adding a rating to clear the error runs into Google's policy line: "Don't mark up irrelevant or misleading content, such as fake reviews or content unrelated to the focus of a page." Google's product snippet documentation requires name plus one of review, aggregateRating or offers, so offers alone meet its required list. We found no mention of software or subscriptions in that page's guidance, and its examples are physical goods, so Product on a SaaS pricing page is a judgment call.

What the pricing page showsOuter typeGoogle feature it maps toGoogle's required fields
Real ratings or reviews of the appWebApplicationSoftware app rich resultname, offers.price, aggregateRating or review
Plans and prices onlyWebApplicationNone (the rating requirement is unmet)Rich result needs a rating or review
Plans and prices onlyProductProduct snippetname, plus one of offers, review or aggregateRating

The Offer structure underneath is identical in every row, so the outer type can change later without touching plan data.

How plans and billing periods map to Offer and UnitPriceSpecification

Each plan becomes one Offer, and its billing periods sit one level down in priceSpecification as UnitPriceSpecification objects. Schema.org defines billingDuration on UnitPriceSpecification this way: "Specifies for how long this price (or price component) will be billed." The same entry says it can model the contractual duration of a subscription, and a sibling property, billingStart, covers a price that changes partway through, such as an increase after a subscription's first year. billingDuration accepts a Duration, a Number paired with unitCode, or a QuantitativeValue. The template uses Duration values, which schema.org says take ISO 8601 duration format, so P1M is one month and P1Y is one year.

One Google rule shapes the whole block. The product snippet page says that when an Offer carries both a price and a priceSpecification, Google uses offers.price and ignores priceSpecification, and the software app page requires offers.price outright. Set offers.price to the figure your table shows by default, and let priceSpecification carry the monthly and annual detail for every other parser.

A copy-ready three-plan JSON-LD template

The JSON-LD below is the product pricing markup we would hand any team that wants search engines, LLMs and AI crawlers reading the same plan data as buyers. It describes a hypothetical product, Tallyroom, whose table opens on monthly billing: a Free tier, a Team plan at $49 a month or $470 a year, and a Business plan at $149 a month or $1,430 a year. Its Enterprise tier says "contact sales", so it stays out of the markup; an Offer without a price misses Google's required offers.price.

{
  "@context": "https://schema.org",
  "@type": "WebApplication",
  "name": "Tallyroom",
  "applicationCategory": "BusinessApplication",
  "operatingSystem": "Web browser",
  "offers": [
    {
      "@type": "Offer",
      "name": "Free",
      "price": "0",
      "priceCurrency": "USD"
    },
    {
      "@type": "Offer",
      "name": "Team",
      "price": "49.00",
      "priceCurrency": "USD",
      "priceSpecification": [
        {
          "@type": "UnitPriceSpecification",
          "name": "Team, billed monthly",
          "price": "49.00",
          "priceCurrency": "USD",
          "billingDuration": "P1M"
        },
        {
          "@type": "UnitPriceSpecification",
          "name": "Team, billed annually",
          "price": "470.00",
          "priceCurrency": "USD",
          "billingDuration": "P1Y"
        }
      ]
    },
    {
      "@type": "Offer",
      "name": "Business",
      "price": "149.00",
      "priceCurrency": "USD",
      "priceSpecification": [
        {
          "@type": "UnitPriceSpecification",
          "name": "Business, billed monthly",
          "price": "149.00",
          "priceCurrency": "USD",
          "billingDuration": "P1M"
        },
        {
          "@type": "UnitPriceSpecification",
          "name": "Business, billed annually",
          "price": "1430.00",
          "priceCurrency": "USD",
          "billingDuration": "P1Y"
        }
      ]
    }
  ]
}

The free tier uses price 0, as Google's software app page specifies for apps available without payment. priceCurrency appears everywhere because Google recommends it for paid apps and product snippets and requires it for merchant listings. If your table opens on annual billing, make the annual total the buyer is charged the offers.price and print that total on the page. Schema.org's own annual-fee example on the UnitPriceSpecification page expresses the period as a referenceQuantity with unitCode ANN, which works too; pick one convention and use it across the block. If the page displays real ratings, add an aggregateRating with the same value and count the page shows.

Keeping the markup identical to the plan table

Google's policy page sets two rules that pricing pages break without anyone noticing. "Your structured data must be a true representation of the page content." And: "Don't mark up content that is not visible to readers of the page." The usual causes are mechanical:

  • A billing toggle that puts only one period in the HTML while the JSON-LD lists both. Print both as text, for example "$49 a month, or $470 a year billed annually".
  • A price edited in the CMS while the JSON-LD lives in a hardcoded template. Generate both from one data source.
  • Rounded monthly equivalents. A table that says "$39/mo billed annually" for the $470 plan should also show the $470 total the markup states.
  • A priceValidUntil left over from a promotion. Google's product snippet page warns that a past date may stop the snippet from showing.

If the plan table renders client-side, check what crawlers receive; our piece on whether GPTBot and Google-Extended render JavaScript works through that question. The same prices also need to agree with review sites, directories and your own docs, the subject of LLMs Cite the Brand That Agrees With Itself.

Running the Rich Results Test

Google's policy page names the Rich Results Test and the URL Inspection tool for testing compliance with its technical guidelines. Test the live pricing URL rather than a pasted snippet, so you see what the server sends, and read the result against the table:

  1. The detected item matches the outer type you chose.
  2. Every Offer's price and currency match the visible plan, digit for digit.
  3. The only errors are expected ones. A WebApplication with no rating lacks one of the fields Google lists as required, so we would expect an error on the rating-or-review requirement, and the fixes are real reviews on the page or a different outer type.

Google's product snippet page never mentions billingDuration or subscriptions, so don't expect the test to vouch for the billing periods. Review those objects by hand against the schema.org definitions.

A prompt test for the price assistants quote

After a price change ships, run the same short prompt set in each assistant your buyers use, with web search on where the product offers it. For the hypothetical Tallyroom:

  • "How much does Tallyroom's Team plan cost per month?"
  • "What does Tallyroom cost if I pay annually?"
  • "Does Tallyroom have a free plan?"

Log the date, the assistant, the price quoted and the URL cited, then read the results against this table.

What the assistant saysWhat it suggestsNext step
Current price, cites your pricing pageIt is working from the new pageRe-run after the next change
Old price, cites your pricing pageIts copy of the page predates the changeConfirm crawler access, resubmit (IndexNow covers Bing), re-test
Old price, cites a review site or directoryA third party holds the stale numberUpdate that listing
Annual total quoted as a monthly priceThe page is vague about billing periodsLabel every figure with its period in visible text

Rule out crawler access first. OpenAI's crawler documentation says "OAI-SearchBot is used to surface websites in search results in ChatGPT's search features," and that after a robots.txt update it can take about 24 hours for its systems to adjust. For Copilot and Bing, the February 10, 2026 AI Performance announcement says "Accurate and up to date content is important for inclusion and citation in AI-generated answers," notes that IndexNow helps keep content current, and describes a report covering total citations, cited pages and the grounding queries behind them. Check it for citations of your pricing URL after each change.

Price accuracy is one slice of AI share of voice, and how to get cited by ChatGPT, Perplexity and AI Overviews covers the content side. Our AI visibility checker is a further resource for spot checks between prompt runs, and pricing, comparison and docs pages run as one program sit within our AI search optimization work.

Sources

Frequently asked questions

Should a SaaS pricing page use SoftwareApplication or Product markup?
Use WebApplication, a SoftwareApplication subtype, when the page shows real ratings or reviews, because Google's software app rich result requires name, offers.price and either aggregateRating or review. With plans and prices only, Product markup meets the product snippet's required list through offers alone, though every example on Google's product snippet page is a physical product. The Offer structure for each plan stays the same under either type.
Does pricing schema make ChatGPT or AI Overviews cite my pricing page?
No markup guarantees a citation. Google states there is no special schema.org structured data needed for AI Overviews or AI Mode, and lists matching structured data to the visible text as a best practice. ChatGPT search depends on OAI-SearchBot reaching the page. Treat the JSON-LD as a consistency layer for your prices, then confirm what assistants say with a recurring prompt test.
How do I mark up an enterprise plan with no listed price?
Leave it out of the offers array. Google's software app documentation requires offers.price, and an Offer with no number restates nothing a buyer can see on the page. Describe the enterprise tier in visible copy, and add it to the markup only when a published price appears in the plan table.
Can one Offer hold both the monthly and the annual price?
Yes. Put each billing period in the Offer's priceSpecification as a UnitPriceSpecification with its own price, priceCurrency and billingDuration. Keep offers.price at the figure your table shows by default, because Google's product snippet documentation says that when both are present Google uses offers.price and ignores priceSpecification. Both prices should also appear as visible text on the page.
What happens if the JSON-LD price and the visible price disagree?
The page breaks Google's rule that structured data must be a true representation of the page content, and every parser gets two answers to the same question. Microsoft's Bing Blog put the AI risk plainly: in grounding, a stale fact produces a misleading response. Generate the markup from the same data source as the plan table so one release updates both.

Free tools for this topic

FREE TOOLAI Search Visibility CheckerCan ChatGPT, Perplexity and Google AI see your site?FREE TOOLSEO Page AuditorA senior-level on-page audit in one paste.PLAYBOOKThe AI Search PlaybookGet cited by ChatGPT, Perplexity and Google AI Overviews.

Keep reading

GuidesLLMs Cite the Brand That Agrees With ItselfRead →EcommerceDo GPTBot and Google-Extended Render JavaScript on Product PagesRead →GuidesHow to Get Cited by ChatGPT, Perplexity & AI OverviewsRead →
CATALIST NEWSLETTER

Monthly dose of growth marketing.

Get marketing tips, narratives, guides, and playbooks delivered to your inbox.

Protected by reCAPTCHA — Google's Privacy Policy and Terms of Service apply.