Schema.org for AI: Organization, Product, and FAQ

TL;DR: Schema.org structured data is a block of JSON-LD that states your facts in a machine-readable form: who you are, what you sell and for how much, and your questions and answers. Search engines use it, and AI can parse it easily, though none has confirmed it as a ranking input. Start with three types: Organization, Product or SoftwareApplication, and FAQPage. One caveat: since 2023, FAQ markup rarely shows a rich result in Google.

Most of your website is written for people, which means it is full of persuasion, context, and nuance. A machine reading it has to infer the plain facts underneath: your company name, your price, the answer to a common question. Every inference is a chance to get it wrong.

Structured data removes that guesswork. It is a small, standardized block of code that states the facts directly, in a format built for machines. The visible page stays the same. Underneath it, you hand parsers a clean list of what is true.

This guide explains what structured data is, the three types worth adding first, and how to validate them, with an honest note on what it does and does not do in 2026.

What structured data actually is

Schema.org is a shared vocabulary for describing things: an organization, a product, a person, an FAQ. JSON-LD is the format used to write that vocabulary into a page. It sits inside a <script type="application/ld+json"> tag, usually in the page head, and it is invisible to visitors.

This is different from semantic HTML, which we covered separately. Semantic HTML describes the shape of your visible content using elements like headings, lists, and tables. Structured data adds a parallel layer of explicit facts on top. One makes your content readable. The other makes your facts unambiguous. They work best together.

Here is the whole idea in one small example:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "Example SaaS",
  "url": "https://www.examplesaas.com"
}
</script>

A parser reading that does not have to guess whether "Example SaaS" is a company, a product, or a headline. You told it.

Why it helps, and the one rule that keeps you safe

The value is clarity. Structured data separates facts from copy, so systems that can read it do not have to reverse-engineer your pricing or your company name from marketing language. Search engines use it to understand entities and to power some search features. JSON-LD is the format Google recommends, per Google Search Central. It works best alongside metadata that states the same facts, so titles, descriptions, and schema do not tell different stories.

There is one rule that keeps this out of trouble: your markup must match what a visitor can actually see on the page. Do not mark up a price that is not published. Do not add FAQ markup for questions that are not on the page. Structured data describes visible content, it does not invent it, and search engines can penalize markup that misleads.

Three schema types every SaaS should start with

You do not need to mark up everything. For a B2B SaaS site, three types cover most of the value.

Organization: who you are

Organization schema states your company as an entity: the name, the official site, the logo, and your real social profiles. The sameAs list is the useful part, because it connects your site to the profiles that confirm your identity elsewhere. Put this on your homepage or sitewide.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "Example SaaS",
  "url": "https://www.examplesaas.com",
  "logo": "https://www.examplesaas.com/logo.png",
  "sameAs": [
    "https://www.linkedin.com/company/examplesaas",
    "https://x.com/examplesaas",
    "https://github.com/examplesaas"
  ]
}
</script>

Product or SoftwareApplication: what you sell and for how much

For a software product, SoftwareApplication with an Offer states the product, its category, and a concrete price in a specific currency. Put it on the product or pricing page.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "SoftwareApplication",
  "name": "Example SaaS Platform",
  "applicationCategory": "BusinessApplication",
  "operatingSystem": "Web",
  "url": "https://www.examplesaas.com/pricing",
  "offers": {
    "@type": "Offer",
    "price": "49",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock"
  }
}
</script>

One honest limit: this only works if a real price is published on the page. If your pricing is "contact us" or "custom," you cannot mark up a concrete Offer with a number, and you should not invent one. Mark up what is actually there.

FAQPage: your answers, in a machine-readable form

FAQPage schema turns your on-page questions and answers into structured pairs, each question with one accepted answer. It belongs on a page that actually shows those questions and answers.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "Do you offer a free trial?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Yes. Every plan includes a 14-day free trial with no credit card required."
      }
    }
  ]
}
</script>

Here is the caveat that matters. In August 2023, Google restricted FAQ rich results to well-known, authoritative government and health sites, per Google Search Central. For a normal SaaS site, FAQPage markup will almost never produce the old expandable FAQ under your search result anymore. It still has a purpose: it gives any system that reads your page a clean, labeled version of your Q&A. Just do not add it expecting the rich result Google used to show.

Do AI engines actually read your schema?

This is where honesty matters, because the claims online run ahead of the evidence.

Search engines definitely use structured data. That part is documented, and it drives features like product and review snippets where you qualify. JSON-LD is the format Google and others prefer.

AI answer engines are less clear. Their crawlers read the raw HTML where your JSON-LD lives, and structured facts are easy to parse, so it is plausible that schema helps them extract your details cleanly. But no major AI engine has publicly confirmed that it uses Schema.org markup as a ranking or citation input. Treat structured data as a low-cost way to state your facts clearly, not a proven control panel for AI answers. You are reducing ambiguity, which supports how ChatGPT understands and recommends your product even when no system exposes its exact formula.

How to add and validate it

The mechanics are simple.

1. Write the JSON-LD for the page, using only facts that appear on that page.
2. Place it in a <script type="application/ld+json"> tag. In the page head is common, and the body works too. Make sure it is in the HTML your server returns, not injected later by JavaScript, since many crawlers do not run scripts and can miss client-side markup.
3. Use the right type per page: Organization sitewide, SoftwareApplication or Product on pricing and product pages, FAQPage where you show Q&A.
4. Validate before shipping. Google's Rich Results Test shows whether a page is eligible for any remaining rich result, and the Schema Markup Validator checks that your syntax and types are correct.
5. Recheck after changes. If your price or plan names change, update the markup, the same discipline a sitemap needs.

Common mistakes to avoid

• Marking up facts that are not visible on the page. This is the fastest way to get flagged.
• Inventing an Offer price when your pricing is "contact us." Leave the price out rather than fake it.
• Adding FAQPage markup and expecting the old Google rich result. That mostly ended in 2023.
• Using more than one format at once, like JSON-LD plus Microdata for the same data. Pick JSON-LD and keep it single.
• Setting it and forgetting it. Stale markup that no longer matches the page is worse than none.

Where SupaIntent fits

Adding structured data states your facts clearly. It does not tell you whether AI systems now describe your product correctly, which competitors they recommend, or which of your pages they pull from. Seeing that requires measuring your real presence across ChatGPT, Gemini, Perplexity, and Google AI Mode. That is what SupaIntent helps with, connecting technical clarity to the answers buyers actually see.

FAQ

What is Schema.org structured data?

Schema.org is a shared vocabulary for describing things like an organization, a product, or an FAQ. You write it in JSON-LD, a small block of code inside a script tag that states your facts in a machine-readable form. It is invisible to visitors and sits alongside your normal page content.

Does structured data help with AI search?

It can, but it is not confirmed. Search engines use structured data to understand pages and power some features. AI answer engines read the raw HTML where JSON-LD lives, so it is plausible they parse it, but none has publicly confirmed using it as a ranking input. Treat it as a clear way to state your facts, not a guaranteed AI lever.

Which schema types should a SaaS site use first?

Start with three. Organization for your company identity, sitewide. SoftwareApplication or Product with an Offer for your pricing or product page. FAQPage where you show questions and answers. These cover most of the value for a B2B SaaS site.

Does FAQPage schema still work in 2026?

It still works as a machine-readable version of your Q&A, but it rarely produces a rich result. In August 2023, Google restricted FAQ rich results to authoritative government and health sites, so a normal SaaS site will not see the old expandable FAQ under its search listing.

Where do I put JSON-LD, and how do I check it?

Place the JSON-LD in a script tag, commonly in the page head. Then validate it with Google's Rich Results Test for eligibility and the Schema Markup Validator for correct syntax. Only mark up facts that a visitor can see on the page.

Structured data will not rank you or write your content. What it does is remove ambiguity: it lets you state, in plain machine-readable terms, who you are, what you sell, and what you charge. For the systems that increasingly answer on your behalf, that is a small, honest way to make sure your facts are your own.