Schema Markup Generator

This schema markup generator writes JSON-LD structured data for eight schema.org types — Article, Product, FAQ, LocalBusiness, Organization, Person, Event and HowTo — and hands you valid JSON-LD in a copy-ready <script type="application/ld+json"> block. Everything runs in your browser: the names, prices and addresses you type never leave your machine, which matters when you are preparing markup for unpublished products or an event that has not been announced. Call it a JSON-LD generator, a structured data generator or a plain schema generator — the output is the same file, and the spelling of the format (JSON-LD, json ld, jsonld) changes nothing for the parser.

One honest note first: the tool produces JSON-LD only — no Microdata, no RDFa. The section on formats explains why that is the right default and what to do if you need inline attributes.

What schema markup does on a page

Schema markup — structured data — is a machine-readable description of a page’s subject that sits next to the human-readable content. It uses the shared vocabulary published at schema.org: a Product has a name, an offers block with a price, an aggregateRating; an Event has a startDate and a location. Search engines read that description to confirm what the page is about and, for some types, to render an enhanced listing — the rich snippets you see beneath a result’s title. If you are new to the concept, start with schema markup for beginners; developers who want the full syntax can go straight to the JSON-LD structured data guide.

Google’s own documentation collects the commercial case for doing this. In its introduction to structured data it cites Rotten Tomatoes measuring a 25% higher click-through rate on pages with structured data, Nestlé seeing an 82% higher CTR for pages shown as rich results, and Rakuten finding users spent 1.5× longer on marked-up pages. Those are large sites with mature implementations; the realistic expectation for a small site is a cleaner listing and fewer misreadings of the page, with rich results as the upside rather than the guarantee.

Why use this schema markup generator tool

Structured data tools come in three shapes: online generators like this one, plugins inside a CMS, and enterprise platforms that inject markup site-wide. A generator is the right pick when you need one correct block now — for a landing page, a static site, a headless build, or to check what a plugin should be producing.

Two things help in daily use. The output updates as you type, so you see how a priceRange or an aggregateRating changes the block without reading the spec. And the required properties stay in front of you — the asterisks follow Google’s feature documentation — so a missing image or address is caught before you paste anything.

Which schema types the generator covers

Pick the type that describes the dominant content of the page, not every type it could conceivably carry. Each entry notes what the JSON-LD schema block contains and whether Google currently shows a rich result for it; the next section tabulates that status against Google’s search gallery.

• Article — blog posts, news, editorial pages. Produces headline, image, datePublished, dateModified, an author Person and a publisher Organization with logo. Eligible for the Article rich result — better title text, images and date information in the listing. Top Stories is a separate question: Google states that no markup is required to be eligible for its News features, so Article tells Google more explicitly what the page is about rather than buying a slot in the carousel.
• Product — a product page with offers (price, currency, availability) and an optional aggregateRating. Eligible for product snippets and merchant listings. This is the type where a wrong decimal separator or a currency symbol inside the price breaks everything.
• FAQ — an FAQPage with a mainEntity array of Question and Answer nodes. Still valid schema.org markup and still useful for other consumers, but Google stopped showing the FAQ rich result on 7 May 2026 — see the table below and the FAQ schema guide for what that means in practice.
• LocalBusiness — a store, restaurant, clinic or agency with a PostalAddress, telephone, url and priceRange. Used as a local business schema generator, the form lets you choose a subtype such as Restaurant or Dentist, which is what Google asks for. The local business schema guide covers opening hours, multi-location sites and NAP consistency in depth.
• Organization — company-level facts: name, url, logo, email, telephone, foundingDate. Feeds knowledge panels and the logo shown next to your brand in some results; normally placed once, on the homepage.
• Person — an author or public figure with jobTitle, worksFor and profile links. There is no stand-alone Person rich result; the type earns its keep as the author of articles and as the mainEntity of an about page.
• Event — a conference, concert or webinar with startDate, endDate, a location Place and an organizer. Eligible for Google’s event listings when the page describes a real, dated, attendable event.
• HowTo — ordered HowToStep items with an optional totalTime. Google retired the How-to rich result in September 2023, so keep this type for the markup’s own sake (other search engines, assistants, internal tooling), not for a Google feature.

Types the tool does not cover — Recipe, JobPosting for job posting pages, VideoObject, Course, Review snippets, BreadcrumbList, SoftwareApplication — each have a Google feature guide. Breadcrumbs and review snippets are usually generated by the CMS; for the rest, start from the example in Google’s documentation and check it with the validators below.

Schema types and rich results: what Google still shows

The list of features in Google’s search gallery shrinks more often than it grows, and a lot of guidance online still promises rich snippets that Google no longer shows. The status column reflects the gallery and the Search Central changelog as of August 2026 — FAQ rich results were retired on 7 May 2026 and their documentation was removed in June; How-to rich results went in September 2023.

“Retired” means the visual treatment is gone, not that the markup is wrong. A FAQPage block still passes validation and still tells any crawler that the page holds canonical question-and-answer pairs. What changed is the return: if you added FAQ markup purely to win an accordion in Google, that reason has expired.

JSON-LD vs Microdata vs RDFa: which format should you generate?

Generate JSON-LD. Google states in its structured data introduction that it recommends JSON-LD where a site’s setup allows it, because the block is separate from the visible HTML and therefore easier to write, template and maintain. Microdata and RDFa are equally valid to schema.org and still read by Google — they are just harder to keep correct.

People still search for a “microdata generator” mostly because older themes and shop templates shipped with Microdata baked in. This tool does not generate it. If you must translate, the mapping is mechanical: @type becomes itemscope itemtype="https://schema.org/Product" on a wrapper element, and every key becomes an itemprop on the element showing that value. Do not mix formats for the same entity on one page, or the validators will double-count reviews and offers.

How to add schema markup to a website: head, body, Tag Manager, WordPress

Paste the whole block, <script> tags included, into the HTML of the page it describes. Google reads JSON-LD from <head> and from <body>, and from blocks injected by JavaScript after load. The exact route depends on your stack.

Static HTML or a site generator

Put the block in the page template’s <head>, next to the title and meta tags. Hugo, Eleventy, Astro and Next.js all let you fill the values from front matter or page props, which is the point at which a hand-pasted example becomes a template. Keep it one block per entity: an article page gets an Article block; the homepage gets the Organization block; do not repeat Organization on every page.

Google Tag Manager

Create a Custom HTML tag, paste the block, and fire it on the relevant page-view trigger. Google documents this route in Generate structured data with JavaScript and adds a caution worth repeating: use GTM variables to read values from the page rather than retyping them in the tag, otherwise the markup drifts from the content. For Product pages the same guide warns that dynamically generated markup can make Shopping crawls less frequent — server-rendered JSON-LD is safer for prices and stock.

WordPress

Three things to know. Yoast SEO, Rank Math and similar plugins already emit an Article, WebPage, Organization and BreadcrumbList graph on every post, so pasting a second Article block creates a duplicate entity — use the generator for types the plugin does not produce (Event, Product on a non-shop page, a detailed LocalBusiness) or to check what the plugin should be saying. Second, do not paste the script into the visual editor; it will be escaped and printed as text. Put it in a “header scripts” field if your theme or plugin provides one, or hook it into wp_head from a small must-use plugin. Third, after deploying, clear the page cache before testing, or you will validate the old page.

Headless and single-page apps

Render the block into the server response when you can. Client-side injection works — Google executes JavaScript and picks up JSON-LD added to the DOM — but it depends on rendering succeeding, and crawlers that do not run scripts never see it. The Schema Markup Validator fetches a URL and shows which blocks it actually saw.

Three ready-to-adapt JSON-LD examples

These are the blocks the generator produces for the three most requested types, with the properties Google’s feature guides list as required or recommended. Swap the example values for your own — or type them into the form above and let the tool do it.

Article

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "How to Brew Cold Coffee at Home",
  "description": "A 12-hour steep, two grind sizes, and what changes the result.",
  "image": "https://example.com/images/cold-brew-16x9.jpg",
  "datePublished": "2026-08-19T09:00:00+02:00",
  "dateModified": "2026-08-19T09:00:00+02:00",
  "author": {
    "@type": "Person",
    "name": "Anna Novak",
    "url": "https://example.com/about-anna"
  },
  "publisher": {
    "@type": "Organization",
    "name": "Example Coffee Journal",
    "logo": { "@type": "ImageObject", "url": "https://example.com/logo.png" }
  }
}
</script>

Google lists no required properties for Article — every field is “recommended” — but headline, image, datePublished and an author with a url are the ones that do the work. Dates are ISO 8601 with a timezone offset; without the offset Google assumes the crawler’s timezone.

LocalBusiness (Restaurant subtype)

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Restaurant",
  "name": "Harbour Street Kitchen",
  "image": "https://example.com/images/dining-room.jpg",
  "url": "https://example.com/",
  "telephone": "+44 20 7946 0321",
  "priceRange": "££",
  "address": {
    "@type": "PostalAddress",
    "streetAddress": "14 Harbour Street",
    "addressLocality": "Whitstable",
    "addressRegion": "Kent",
    "postalCode": "CT5 1AG",
    "addressCountry": "GB"
  },
  "openingHoursSpecification": [
    { "@type": "OpeningHoursSpecification",
      "dayOfWeek": ["Tuesday","Wednesday","Thursday","Friday","Saturday"],
      "opens": "12:00", "closes": "22:00" }
  ]
}
</script>

For local business markup Google requires name and a structured address; the subtype (Restaurant here rather than the generic LocalBusiness) and opening hours are what make the knowledge panel complete. Keep the address character-for-character identical to the one in your Business Profile.

Product

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Ceramic Pour-Over Dripper, 2-Cup",
  "image": "https://example.com/images/dripper-white.jpg",
  "description": "Hand-glazed stoneware dripper for 02-size paper filters.",
  "sku": "DRP-02-WHT",
  "brand": { "@type": "Brand", "name": "Example Ceramics" },
  "offers": {
    "@type": "Offer",
    "url": "https://example.com/dripper-white",
    "price": 24.00,
    "priceCurrency": "EUR",
    "availability": "https://schema.org/InStock"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": 4.7,
    "reviewCount": 132
  }
}
</script>

Product snippets need name plus at least one of offers, review or aggregateRating. The price is a plain number with a dot as decimal separator, and the currency is a three-letter ISO 4217 code in priceCurrency — “€24” in the price field is the single most common Product error we see.

How to validate schema markup: two tools, two jobs

Whichever schema markup generator produced the block, run it through both validators, because they answer different questions. The Schema Markup Validator checks the markup against the schema.org vocabulary: is the JSON well-formed, are the types and property names real, does the nesting make sense. It extracts JSON-LD, Microdata and RDFa from a URL or a pasted snippet and shows the full graph it found, which is the fastest way to spot a duplicate Organization or a block your CMS added behind your back. It does not know or care about Google’s feature requirements.

Google’s Rich Results Test answers the narrower question: is this page eligible for a Google rich result, and which one. It flags missing required properties per feature (an Offer without a price, an Event without a startDate) and previews the listing for many types. It ignores types that have no Google feature — a perfectly valid Person or HowTo block will simply not be mentioned, which is not an error.

After the page is live, Search Console’s enhancement reports (Products, Events, Breadcrumbs and so on) show whether Google found the markup at crawl time and which items carry warnings. That report is the one that catches templating regressions weeks later, when nobody is running the test tools by hand.

Common schema markup mistakes

Most rejected or ignored markup fails for one of a short list of reasons, and a generator removes only the syntax errors from that list. The rest are editorial decisions.

• Describing content that is not on the page. Ratings with no visible reviews, an FAQ block for questions nobody can read, a price the page does not show. Google’s structured data guidelines call this out explicitly, and it is the fastest route to a manual action.
• Duplicate entities. A plugin emits Article and you paste another Article; a theme emits Organization on every page. Validate the whole URL rather than your snippet alone, and remove the copy.
• Wrong page, right type. Product markup on a category listing, LocalBusiness on a blog post, Event on a recap of last year’s conference. The type has to describe the primary content of that URL.
• Formatting slips in values. Currency symbols in price, dates written as “19/08/2026” instead of ISO 8601, relative image URLs, a telephone without country code.
• Too generic a type. LocalBusiness when Dentist exists; Thing when anything more specific would do. Specific types get the specific panel.
• Stale dates. dateModified that never changes, or changes on every page load. Update it when the content actually changes.
• Never looking again. Markup is rendered by templates, and templates get edited. Check the Search Console enhancement reports after every theme or plugin update.

Does schema markup help with AI search?

Indirectly, and without any special markup. Google’s guidance on AI features and your website states that no additional requirements and no special schema.org type are needed to appear in AI Overviews or AI Mode; what it asks is that structured data matches the visible text. Clean, accurate JSON-LD helps a system resolve which product, which business, which author a page is about; invented or inconsistent markup hurts. Treat the generator as a way to state facts precisely, not as a lever for a feature.

Frequently Asked Questions