Skip to main content

JSON-LD Schema Generator

What it does

The JSON-LD Schema Generator turns a few form fields into copy-ready structured data for the schema types Google actually uses to award rich-snippet treatment. Pick a type, fill in the headline fields the spec requires, and the generator emits a <script type="application/ld+json"> block ready to drop into your <head>. It covers Article, Organization, LocalBusiness, Product, FAQPage, BreadcrumbList, Event, Recipe, and HowTo — the nine types that account for the vast majority of rich-result eligibility on real sites.

Common situations

You are publishing a new article and want it eligible for the headline result with the author and date — Article schema is the right shape, and the generator gets the required fields (headline, author, datePublished, image, publisher) and the mainEntityOfPage wiring correct without you having to remember the JSON-LD nesting.

A product page is missing offer markup and the missing star rating in search results is costing clicks. Product schema with Offer, priceCurrency, price, and availability fixes that. The generator emits the offer block correctly nested inside the product, which is the bit that catches people writing schema by hand.

You are setting up a local business profile for a single-location client and need the LocalBusiness markup to match what Google’s Business Profile expects — name, address, telephone, opening hours, price range. The generator emits the PostalAddress sub-object correctly, which is the part Google’s Rich Results Test rejects most often when schema is hand-written.

A long-form article has a frequently-asked-questions section at the bottom and you want it eligible for the FAQ rich snippet. FAQPage schema with mainEntity containing Question/Answer pairs is what unlocks that. The generator builds the array structure and the @type wiring on each item correctly.

You are building a recipe site or a step-by-step how-to article. Recipe and HowTo schema have the most fiddly nesting (ingredients, instructions with step ordinals, time durations as ISO 8601) and the most error-prone hand-written output. The generator emits ISO durations (PT15M, PT30M) and HowToStep ordinals correctly without you having to look them up.

What you need to know

Schema.org structured data is the canonical vocabulary for telling search engines what a page contains. JSON-LD is the format Google explicitly recommends — it sits in a script tag in the head, separate from the rendered HTML, and does not interfere with anything else on the page. The alternative formats (microdata, RDFa) are still valid but are no longer the recommended path for new work.

Google publishes a structured data feature reference listing exactly which types are eligible for which rich-snippet treatments. Article, Product, FAQPage, BreadcrumbList, Event, Recipe, and HowTo all map to specific rich-result formats — that is why those types are in this generator and not, say, CreativeWork or Thing. The generator covers Organization and LocalBusiness as well because they are foundational entity-identification types most sites need on at least the homepage and contact page, even though they do not award their own rich result.

The most common mistake when writing schema by hand is omitting required fields and getting the page invisibly disqualified from rich results — Google’s Rich Results Test reports the failure but most sites do not run it consistently. The generator forces you through the required fields for each type, so the output is automatically eligible for the corresponding rich result. Recommended fields are optional but supplying them increases the chance of richer presentation: Article without image is eligible but cleaner with it; Product without aggregateRating is eligible but does not show stars.

Two things the generator deliberately does not cover. The first is multi-type schema (a single thing that is both Article and NewsArticle, or a Product that is also an Event). Most real pages are a single type with one or two child entities — the generator covers that 90% case cleanly. The other 10% involves enough type-graph reasoning that a generator UI obscures more than it helps. The second is invisible schema — JSON-LD that does not match the page’s visible content. Google penalises this. The generator does not stop you, but the spec rule is: the schema must reflect what the user sees.

When you have generated schema, paste it back into the Schema Validator for a final sanity check, and into Google’s Rich Results Test for Google-specific eligibility before shipping.

Frequently asked questions

What’s the difference between JSON-LD, microdata, and RDFa?

All three are formats for embedding schema.org structured data in HTML. JSON-LD sits in a separate script tag and is the format Google recommends for new work. Microdata uses inline itemtype and itemprop attributes; RDFa uses vocab and typeof. Microdata and RDFa still parse correctly but are awkward to maintain alongside templating systems. Use JSON-LD unless you have a specific reason not to.

Where in the HTML should JSON-LD go?

Either inside the <head> or anywhere in the <body> — Google parses both. The convention is <head> because it groups with other metadata, but pages with multiple schema blocks (an Article plus a BreadcrumbList plus an Organization) often place them in different parts of the page near the content they describe.

Can I have more than one schema block on a page?

Yes. A typical content page has at least three: the Organization (declared once site-wide), a BreadcrumbList, and the page’s main type (Article, Product, etc.). Multiple application/ld+json script tags is the standard pattern. Alternatively, use a single block with @graph containing an array — same outcome, slightly tidier source.

What schema type should I use for blog posts?

Article, BlogPosting, or NewsArticle — they are all subtypes of Article and inherit the same Article rich-result eligibility. Use NewsArticle if the site is a news publication; otherwise BlogPosting or Article are interchangeable. Google does not preferentially treat one over the others.

Why isn’t my schema showing as a rich result in Google?

Eligibility is necessary but not sufficient. Google decides which eligible pages get rich treatment based on overall quality, freshness, and click-through patterns. Pages that pass the Rich Results Test but never receive rich treatment are usually competing in topics where Google’s confidence in the SERP is high enough that it does not need the extra signal.

Do I need Organization schema on every page?

No — once on the homepage is sufficient. Repeating it on every page is harmless but adds page weight and gives no additional benefit. Some templates inject site-wide Organization markup; that’s fine — Google de-duplicates.

How do ISO 8601 durations work?

Format: PT[hours]H[minutes]M[seconds]S. So 15 minutes is PT15M, an hour and a half is PT1H30M, and a 90-minute total is PT90M or PT1H30M (both valid). For Recipe and HowTo schemas, prep time and cook time use this format.

Should I include ratings if I don’t have many reviews?

If you have fewer than three or four real reviews, omitting aggregateRating is usually better than including it. A rating with reviewCount: 1 looks worse than no rating at all in the SERP, and Google sometimes ignores aggregate ratings with very low review counts.

Common problems

Problem: Rich Results Test reports “Missing field ‘image'” on Article schema.

image is a Google-specific requirement for Article rich results, even though schema.org’s spec marks it as recommended only. Always include image on Article schema — at minimum a 1200×630 hero — and the Rich Results Test will pass.

Problem: Google’s Rich Results Test passes but Search Console reports the page as “not eligible” for rich results.

Search Console eligibility lags by days or weeks behind real-time validation. After publishing or fixing schema, request indexing in Search Console’s URL Inspection, then wait for the next eligibility update. The gap between Rich Results Test (instant) and Search Console (delayed) is normal.

Problem: FAQPage schema validates but doesn’t appear as an FAQ rich snippet.

In August 2023 Google reduced FAQ rich snippets to “select authoritative websites only” for most queries. The schema is still correct and eligible, but Google now selectively chooses which sites get the treatment. The fix is not on your side — your schema is doing what it should.

Problem: Multiple @type values cause “Invalid value” errors in the validator.

Multi-type schema ("@type": ["Article", "NewsArticle"]) is technically valid but rejected by some validators. Use one type per script — emit two separate schema blocks if a thing is genuinely two types — and the issue disappears.

Problem: Hand-written schema works locally but fails in production with strange escape errors.

Most likely the page template is HTML-encoding the JSON content (turning " into &quot;). The generator’s output assumes raw HTML insertion. Check that your CMS is not escaping <script type="application/ld+json"> content — it should not.

Tips

  • Match the schema to what’s visible. If the schema declares an aggregateRating but the page doesn’t show it, Google considers this a violation and may demote rich-result eligibility.
  • Use the Schema Validator for fast required-field checks and Google’s Rich Results Test for production eligibility — they catch slightly different issues.
  • For multi-page sites with consistent structure (a publication, a product catalog), generate schema once and template it. Hand-writing per page is where mistakes sneak in.
  • BreadcrumbList schema is one of the highest-ROI types — easy to implement, frequently shown, and most templates already have the breadcrumb data.
  • Schema does not improve rankings directly. It improves SERP appearance, which improves click-through. The two are correlated but distinct.

Related tools in this suite

After generating schema, the Schema Validator is the next stop — paste the output back in and check that required and recommended fields are all present. The Page SEO Audit then tells you whether the schema is actually being served (sometimes templates strip script tags unexpectedly).

What this looks like at scale

Generating schema page by page is fine for a small site or a one-off addition. For a large content set — a recipe site, a product catalog, a publication — the schema needs to come from the data layer, not the template. That kind of work falls under the systems we build — content models that emit correct schema as a side effect of how the data is structured.

Take it further

If you are looking at a content set where consistent schema across hundreds of pages matters, start a conversation about how to architect it from the data layer rather than retrofitting it into templates.