# Schema Generator for AI Search: Which Types to Pick

> Which schema types a schema generator should output for AI search, which are noise, and a 5-step validation routine. Free JSON-LD tool included.

- Author: Sheetal Shakshi, Founder's Office, Nurdd
- Published: 2026-11-17
- Publisher: Noma by Nurdd (https://nomahq.app)
- Original page: https://nomahq.app/blog/schema-generator-for-ai-search

A schema generator is worth using for AI search when it writes JSON-LD for facts that are already visible on your page: who you are (Organization), what a page is (Article, Product, SoftwareApplication, LocalBusiness) and where it sits (BreadcrumbList). Skip decorative types. Schema helps engines read a page; it does not guarantee a citation.

## Key takeaways

- Generate Organization first, with name, URL, logo and `sameAs` profile links, so engines can tie mentions of you to one entity.
- Add one page-level type per page (Article, Product, SoftwareApplication, LocalBusiness or Service) and make every value match visible copy.
- Treat FAQPage and HowTo as optional: Google has removed their rich results, so they earn no search appearance.
- Do not expect schema alone to raise citations. In Ahrefs' 2026 test of 1,885 pages, adding JSON-LD produced no clear uplift.
- Validate in three places: the generator's checks, Google's Rich Results Test and the raw server HTML, then measure what AI engines say about you.

## What schema markup should I add to help AI engines understand my site?

Start with the entity, then the page. Engines have to decide whether a brand mention on one site and a product page on another refer to the same thing. Organization markup, with a stable name, URL, logo and links to your real profiles, gives them a declared answer instead of an inference. Page-level markup then states what each URL is.

The official position is modest. Google Search Central's guide to generative AI features lists over-focusing on structured data as a mistake and says [Google Search Central: "Structured data isn't required for generative AI search"](https://developers.google.com/search/docs/fundamentals/ai-optimization-guide), adding that no special schema.org markup is needed. Microsoft has been more positive. At SMX Munich in March 2025, Bing's Principal Product Manager Fabrice Canel reportedly said schema markup helps Microsoft's LLMs understand content, as [Search Engine Roundtable, March 2025](https://www.seroundtable.com/schema-llms-copilot-bing-microsoft-39093.html) reported from a post by David Mihm.

Read those together: schema is a clarity tool, not a ranking lever. Generate it because it removes ambiguity cheaply, and keep your expectations at that level.

## What does the evidence say about schema and AI citations?

The best public test is Ahrefs'. Its team first analysed 6 million URLs and found AI-cited pages were almost three times more likely to carry JSON-LD than non-cited pages. Then it ran a second study to check cause. It tracked 1,885 pages that added JSON-LD between August 2025 and March 2026, matched them against 4,000 control pages and measured changes. The results, per [Ahrefs, May 2026](https://ahrefs.com/blog/schema-ai-citations/):

| AI source | Effect of adding schema on citations | Ahrefs' reading |
| --- | --- | --- |
| Google AI Overviews | -4.6% | Small, statistically significant; treated and control pages were both already declining |
| Google AI Mode | +2.4% | Indistinguishable from zero |
| ChatGPT | +2.2% | Indistinguishable from zero |

The first number is the trap. Schema is common on cited pages because well-run sites do many things well: they publish strong content, earn links and maintain their markup. Schema rides along with those signals. That is correlation, and the matched test shows adding the markup on its own did not move citations.

This changes how you should use a generator. Its job is accuracy and consistency across your site, not a promise of visibility. A page with weak content and perfect JSON-LD stays weak.

## Which schema types are worth generating, and which are noise?

Use this table as a filter before you open any schema generator. The test is simple: does the type describe something a reader can see on the page, and does an engine need that fact to name or describe you correctly?

| Schema type | Where to use it | What it tells engines | Verdict for AI answers |
| --- | --- | --- | --- |
| Organization | Home page or about page | Official name, URL, logo, profiles | Generate first |
| Article with Person author | Blog posts, guides | Headline, dates, named author | Generate |
| Product | Product pages | Name, price, availability | Generate, with real prices only |
| SoftwareApplication | SaaS product pages | Category, offer, platform | Generate |
| LocalBusiness (or subtype) | Location pages | Address, hours, phone | Generate, one per real location |
| Service | Service pages | What you offer and to whom | Generate when the page is about one service |
| BreadcrumbList | Any nested page | Where the page sits in the site | Low effort, generate |
| FAQPage | Pages with visible Q&A | Question and answer pairs | Optional; no rich result |
| HowTo | Step-by-step pages | Ordered steps | Optional; no rich result |
| Review or AggregateRating | Pages showing real reviews | Ratings | Noise unless every review is visible and genuine |

On FAQ and HowTo, Noma's schema generator page says Google removed HowTo rich results in September 2023 and FAQ rich results in May 2026, though valid markup still describes content to other systems ([Noma by Nurdd, November 2026](https://nomahq.app/tools/schema-generator)). Add them if the visible content genuinely is a question list or procedure. Do not add them hoping for a search appearance.

### Why Organization comes first

Organization is the type that fixes the most common AI error: confusing you with a similarly named company. Include the legal name where it differs, the canonical URL, an absolute logo URL and `sameAs` links to LinkedIn, Crunchbase, Wikipedia or GitHub profiles that exist. If engines already mix you up with another brand, pair the markup with an [entity audit](https://nomahq.app/blog/fix-brand-confusion-in-ai-answers) and a [Wikidata entry](https://nomahq.app/blog/wikidata-brand-entity-ai).

### Why one page-level type beats five

Google's structured data guidelines say to use the most specific applicable type and to mark up a true representation of the page. They also say not to mark up content that readers cannot see ([Google Search Central, July 2026](https://developers.google.com/search/docs/appearance/structured-data/sd-policies)). A product page that also declares itself an Article, a Recipe and an Event is not richer. It is contradictory.

## Is there a free schema generator for JSON-LD?

Yes. Several exist, including standalone generators from SEO agencies and the JSON-LD community site. The [free Noma schema generator](https://nomahq.app/tools/schema-generator) writes JSON-LD for ten types (Organization, local business, product, software or SaaS app, service, article, person, FAQ, how-to and breadcrumbs). It can prefill from your own site, and it also validates structured data already on any public page. It is free with no signup, per the tool page as checked on 2026-11-16.

Whichever generator you pick, check four things before you trust its output:

- **Format:** JSON-LD, which Google recommends over Microdata and RDFa.
- **Prefill:** it should read your real page so values are not retyped from memory.
- **Property warnings:** it should flag missing recommended fields, not just syntax errors.
- **Install steps:** guidance for your stack, such as Next.js, WordPress, Shopify or Google Tag Manager.

## How do I validate schema for AI search in five steps?

A generator proves the JSON is well formed. It does not prove an engine can see it or that it is true. Run this routine on one template, then roll it out.

1. **Generate and read every value.** Open the output and compare each property with the visible page. Prices, hours, author names and dates must match the copy exactly.
2. **Check the server HTML.** View source (not the inspected DOM) and search for `application/ld+json`. If your framework injects it only after JavaScript runs, some crawlers will miss it. The [Next.js indexed HTML guide](https://nomahq.app/blog/nextjs-content-not-showing-in-indexed-html) shows how to test this.
3. **Run the Rich Results Test.** Use [Google's Rich Results Test](https://search.google.com/test/rich-results) to catch syntax and required-property errors. Google notes that markup passing the test still is not guaranteed to appear as a rich result.
4. **Confirm crawlers can reach the page.** Google says not to block structured data pages with robots.txt or noindex. For AI bots, run the [free AI crawler checker](https://nomahq.app/tools/ai-crawler-checker), which shows whether GPTBot, OAI-SearchBot, ClaudeBot and PerplexityBot can crawl the site.
5. **Re-check after every template change.** Prices change, authors leave, locations close. Stale markup is worse than none because it states something false with confidence.

For the surrounding technical basics, [technical SEO for AI search](https://nomahq.app/blog/technical-seo-for-ai-search) covers what Google says to fix first, and [Schema Markup for AI Search](https://nomahq.app/blog/schema-markup-online-for-ai-search) goes deeper on individual properties.

## What mistakes make generated schema useless or risky?

- **Marking up invisible content.** Google's guidelines prohibit it, and a structured data issue can trigger a manual action that removes rich result eligibility.
- **Fabricated ratings.** Reviews not written by real users can lead to a manual action, per the same guidelines.
- **One Organization block copied into every page with different names.** Keep the entity identical everywhere.
- **Treating a passing validator as a result.** Valid is not the same as cited.
- **Ignoring the copy.** Engines quote prose. A short, factual paragraph that states what you do, for whom and at what price will often matter more than the JSON-LD beside it. A [brand fact block](https://nomahq.app/blog/brand-fact-block-for-llms) is one way to write it.

## Worked example: a SaaS team with three page templates

Take a hypothetical software company with a home page, a pricing page and a blog. This is an illustration, not a case study.

| Template | Types to generate | Check before shipping |
| --- | --- | --- |
| Home page | Organization (with `sameAs`) | Name and logo match the site header |
| Pricing and product page | SoftwareApplication with offer, BreadcrumbList | Price in JSON-LD equals price on screen, in the same currency |
| Blog post | Article with Person author, BreadcrumbList | Author page exists; dates match the byline |

That is three templates and about five types. It will not take a team a week. The harder question is what happens afterwards, which is where measurement matters.

## How do I measure whether schema changed what AI engines say?

Ahrefs' test used before-and-after citation counts against matched control pages. You can borrow the logic without its scale. Before you ship, record a fixed set of buyer questions and note which engines name you, which sources they cite and how they describe you. Ship the markup on one template. Re-run the same questions after a few weeks and compare against pages you did not change. Expect noise: AI answers vary run to run, so repeat each prompt, and see [how often AI answers change](https://nomahq.app/blog/ai-citation-stability).

Noma by Nurdd is an answer engine optimisation platform that asks 13 AI engines, including ChatGPT, Gemini, Perplexity and Claude, the questions your buyers ask, every day. It shows where your brand is named, where competitors are named instead, and which pages the answers draw on. That lets you compare answers before and after a schema change, per engine.

See it on your own brand: [book a demo](https://nomahq.app/demo) or [start the 3-day free trial](https://platform.nomahq.app/signup). A card is taken at signup so billing can start on day 3; cancel before then and nothing is charged.

For a quick, free first look, the [free AI SEO checker](https://nomahq.app/tools/ai-seo-checker) shows whether ChatGPT, Claude, Perplexity and Google's AI Overviews can read and quote a page, and the [free AI visibility checker](https://nomahq.app/tools/ai-visibility-check) shows whether engines recommend your brand.

## Where does schema sit among everything else that affects AI answers?

Schema is one input among crawl access, indexation, content that answers the question directly, and third-party mentions. If you are new to the field, [what AEO is](https://nomahq.app/blog/what-is-aeo) explains the full picture. A sensible order of work is: let crawlers in, publish quotable answers, fix entity facts, then add schema to state them in machine-readable form. Schema comes last because it can only describe what the page already says.

## How we researched this

We reviewed Google Search Central documentation on generative AI features and structured data, Ahrefs' published schema and AI citation study, a Search Engine Roundtable report of Microsoft Bing's comments, and the Noma schema generator page. We also searched for free JSON-LD generators and for academic work on schema and AI citation (an SSRN paper on the question exists, but we did not rely on it for figures). We did not run our own citation experiment. Facts, tool capabilities and figures were checked on 2026-11-16.

## What to do next

Open the [free schema generator](https://nomahq.app/tools/schema-generator), prefill it from your site, generate Organization and one page-level type, and run the five-step routine. Then check whether engines name you. To track that daily across 13 AI engines, [book a demo](https://nomahq.app/demo) or [start the free trial](https://platform.nomahq.app/signup).
