Schema Markup Generator — Free JSON-LD Structured Data

Schema Type

Name / Title

Description

URL

Author / Publisher Name

Date Published (YYYY-MM-DD)

Image URL (optional)

What is a Schema Markup?

A Schema Markup Generator is a tool that builds <script type="application/ld+json"> blocks containing structured data in the Schema.org vocabulary. You select a schema type, fill in your page's details, and the generator outputs a ready-to-paste JSON-LD block that you drop into the <head> of your HTML, no knowledge of the Schema.org specification required.

Structured data is machine-readable metadata that tells Google exactly what a page represents: an article, a product, a local business, a set of frequently asked questions, or a step-by-step guide. Without it, Google infers intent from your visible content and links. With it, you explicitly declare your page's structure, which makes your content eligible for rich results, enhanced search listings with star ratings, expandable FAQ dropdowns, breadcrumb trails, product prices, and event details.

JSON-LD is Google's recommended format for structured data. Unlike the older Microdata and RDFa approaches, which require you to annotate individual HTML elements, JSON-LD is a self-contained script block that does not touch your visible markup. It is easier to add, update, and validate, making it the standard choice for developers and non-developers alike.

This generator supports eight schema types used in the majority of rich result implementations: Article, FAQPage, HowTo, LocalBusiness, Product, WebSite, BreadcrumbList, and Person. For complementary SEO technical tags, also see the OG Meta Tag Generator for Open Graph markup and the Robots.txt Generator for crawler access control.

Why Use a Schema Markup Generator?

Writing JSON-LD manually means consulting the Schema.org documentation for every property, checking Google's supported fields and required-versus-recommended distinctions, and making sure your JSON is syntactically valid. A single structural error, a missing comma, an incorrect property name, a mistyped @context URL, silently prevents Google from reading the block entirely. The Rich Results Test tool will catch it, but iterating manually is slow.

This generator handles the structure for you: it knows which properties each schema type requires, nests objects correctly (author as a Person object, image as an ImageObject, offers as an Offer object), and outputs syntactically valid JSON on every generation. You fill in content, not structure.

The output is also opinionated in the right way: it uses https://schema.org (not the deprecated http://), uses @type strings exactly as Schema.org defines them, and omits optional fields you have not filled in rather than emitting empty strings that can trigger validation warnings. For SEO teams and developers shipping multiple pages, a reliable generator is faster and less error-prone than manual authoring.

Who Should Use This Generator?

Bloggers and content publishers who want Article schema on their posts to qualify for Google's Top Stories carousel and author bylines in search snippets.

E-commerce sellers on custom storefronts who need Product schema with price, availability, and brand information for rich product listings in Google Shopping and standard search results.

Local business owners, restaurant owners, clinic operators, service providers, who want their name, address, phone, and hours in a Google Knowledge Panel without relying on a plugin.

WordPress and Wix developers who need schema for custom pages that their SEO plugin does not cover, or who want full control over the exact fields generated.

SEO professionals creating schema for multiple client pages, or auditing and replacing incorrect schema generated by outdated plugins.

Indie developers building landing pages and documentation sites who want to implement structured data correctly from the start without reading specifications. Pair this with the Sitemap Generator for a complete technical SEO foundation.

What Insights Does the Schema Markup Generator Give You?

The generator surfaces what each schema type unlocks in Google Search, understanding these outcomes helps you choose the right type:

Article, enables the AMP news carousel in Google News, the Top Stories carousel on mobile, and displays datePublished and author name in standard search snippets. Best for blog posts, news articles, and editorial content. Required fields: headline, datePublished, author (as a Person object), publisher (as an Organization with a logo).

FAQPage, enables expandable FAQ accordions beneath your search result on desktop and mobile. Each Question / acceptedAnswer pair becomes one collapsible item. When shown, the FAQ expansion can triple the vertical space your result occupies on the page. Requires at least two question-answer pairs and verbatim match between the on-page FAQ text and the schema text.

HowTo, enables a rich result showing your how-to steps directly in search results, sometimes with images per step on desktop. Particularly effective for "how to" queries where Google displays step panels. Requires a name, at least one HowToStep, and optionally an estimatedCost and total time.

LocalBusiness, enables the Google Knowledge Panel on branded searches for your business. Shows name, address, phone, opening hours, and star rating. Google cross-references this schema with your Google Business Profile, consistent data between both signals strengthens your local pack visibility.

Product, enables rich product listings in Google Search with price, currency, availability (in stock / out of stock), and review stars. Also feeds Google's free product listings in the Shopping tab. The Offer object is required; the aggregateRating sub-object enables stars (you must add this manually to the generated block using actual review data).

WebSite, enables the Sitelinks Search Box beneath your homepage result for branded queries. Add this only to your homepage. The potentialAction → SearchAction property tells Google the URL pattern for your internal search, so users can search your site directly from the SERP without visiting it first.

BreadcrumbList, replaces the URL in your search result with a human-readable breadcrumb trail (e.g. example.com › category › page-title). Adds navigational context to the result and is known to improve CTR on category and product pages. Position values must be sequential integers starting at 1.

Person, enables a knowledge panel for individual people, authors, journalists, professionals, public figures, with name, job title, photo, and social profile links. Add the sameAs array in the generated block with links to your Wikipedia, Twitter/X, LinkedIn, and other profile URLs to help Google connect the entity across the web.

How to use this Schema Markup calculator

Select your Schema Type from the Schema Type dropdown. Choose the type that matches the primary purpose of the page you are marking up, for a blog post use Article, for a FAQ section use FAQPage, for a product page use Product.
Fill in the Name / Title field, this becomes the headline for Article, name for LocalBusiness and Product, and the title for HowTo. Use the exact title as it appears on the page.
Enter a Description, a concise, accurate summary of the page content. Google may use this in snippets; keep it under 160 characters for best results.
Enter the canonical URL of the page, the full absolute URL including https://, matching the <link rel="canonical"> in your <head>.
Fill in Author / Publisher Name, for Article this becomes the author.name Person object and the publisher.name Organisation; for Product it maps to brand.name; for LocalBusiness it is not used.
Enter the Date Published in YYYY-MM-DD format (e.g. 2026-01-15). Required for Article schema to qualify for Top Stories.
Add an Image URL (optional but recommended), an absolute URL to the primary image of the page. Google requires a minimum image size of 1200 × 630 px for Article rich results.
Review the JSON-LD Script Block output panel, the complete <script type="application/ld+json"> block appears here, formatted for readability.
Click Copy to copy the block to your clipboard. Paste it inside the <head> element of your HTML page, after the <title> and <meta> tags.
Validate your implementation using Google's Rich Results Test (search.google.com/test/rich-results), paste your page URL or the script block directly to confirm Google can read the schema and that your page is eligible for the specific rich result feature.

Show formula & methodology ↓Show less ↑

Formula & Methodology

JSON-LD structure fundamentals

Every JSON-LD block follows a consistent skeleton:

json <script type="application/ld+json"> {   "@context": "https://schema.org",   "@type": "Article",   "headline": "Your Article Title",   "datePublished": "2026-01-15",   "author": {     "@type": "Person",     "name": "Jane Smith"   },   "publisher": {     "@type": "Organization",     "name": "Jane Smith",     "logo": {       "@type": "ImageObject",       "url": "https://example.com/logo.png"     }   },   "image": {     "@type": "ImageObject",     "url": "https://example.com/article-image.jpg"   },   "description": "A comprehensive guide to digital marketing fundamentals.",   "url": "https://example.com/article/" } </script> 

@context declares the vocabulary namespace, always https://schema.org (note https, not http, which is deprecated). This tells the parser which vocabulary the @type strings and property names belong to.

@type is the entity type from the Schema.org hierarchy, Article, FAQPage, HowTo, etc. Some types have subtypes: LocalBusiness has subtypes like Restaurant, MedicalBusiness, and LodgingBusiness; Article has subtypes NewsArticle and BlogPosting. Subtypes inherit all parent properties and can be more specific.

Nested objects are how JSON-LD expresses relationships. An Article's author is not a plain string, it is an object with its own @type: "Person" and name property. An offer on a Product is an Offer object with price, priceCurrency, and availability. This nesting is what allows Google to understand entities and their relationships, not just flat key-value pairs.

JSON-LD vs Microdata vs RDFa

JSON-LD is a standalone <script> block that is decoupled from HTML. Microdata annotates HTML elements with itemscope, itemtype, and itemprop attributes, every piece of structured data is tied to an HTML element, which means your schema and your visible content must always stay synchronised. RDFa uses a similar in-HTML approach with typeof and property attributes. Both Microdata and RDFa require rewriting HTML to add schema, making them harder to maintain and error-prone when templates change. Google recommends JSON-LD for all new implementations, and it is the only format supported by Google's Rich Results Test for pasted code.

Why properties are omitted when empty

The generator uses conditional spreading to exclude undefined and empty-string properties. An empty "description": "" or "image": "" in schema does not help Google, it can trigger validation warnings in the Rich Results Test and may suppress rich result eligibility. Omitting the property entirely is equivalent to not providing it, which is neutral. This is why the generated output varies in length depending on how many fields you fill in.

Validating your schema

After pasting the generated block into your page:
1. Open Google's Rich Results Test at search.google.com/test/rich-results
2. Enter your page URL (after publishing) or use the "Code snippet" tab to paste the script block directly
3. The tool reports which rich result types your schema qualifies for and flags any missing required fields
4. Address any warnings marked "Required", these prevent the rich result from appearing
5. After fixing, wait for Google to recrawl your page (typically 1–4 weeks for an established site) and check Google Search Console's Rich Results report for impressions

Frequently Asked Questions

What is Schema Markup and why does it matter for SEO?

Schema markup is structured data embedded in a webpage that tells search engines, primarily Google, exactly what your content is about. It uses the vocabulary defined at Schema.org and is most commonly implemented as a JSON-LD script block in the page's `<head>`. Without schema, Google infers page intent from text and links alone; with schema, you explicitly declare that a page is an article, a product listing, a local business, or an FAQ, and Google can use that to show richer, more prominent search results.

What is JSON-LD and how is it different from Microdata or RDFa?

JSON-LD (JavaScript Object Notation for Linked Data) is a structured data format that embeds machine-readable metadata as a standalone `<script>` block in the `<head>` of a page. Unlike Microdata and RDFa, which require you to annotate your existing HTML elements with extra attributes, JSON-LD is completely separate from your HTML markup, you can add it, update it, or remove it without touching the visible content of your page. Google explicitly recommends JSON-LD for all new structured data implementations, and it is the format used by this generator.

Does schema markup directly improve my search rankings?

Schema markup does not directly boost rankings in the way that backlinks or on-page content do. Its primary effect is enabling rich results, enhanced SERP features like star ratings, FAQ dropdowns, breadcrumb trails, and product prices, which improve click-through rates. Higher CTR from the same ranking position effectively increases your organic traffic without changing your position. Some SEOs also argue that rich results improve perceived authority, which can indirectly influence rankings over time, but Google has not confirmed this.

Which schema type should I use for my blog or news site?

Use `Article` for blog posts and standard editorial content. `Article` schema enables the AMP news carousel in Google News and the Top Stories carousel on mobile, shows your article's datePublished in search snippets, and displays author information. If your page contains questions and answers, like a FAQ section at the bottom of a post, you can add a `FAQPage` schema block alongside the `Article` block on the same page (multiple schema types on one page are supported). For a full website root page with a sitelinks search box, add `WebSite` schema to your homepage.

Which schema type should I use for a local business like a restaurant or shop?

Use `LocalBusiness` for any brick-and-mortar or service-area business. This schema type enables the Google Knowledge Panel, the information card that appears on the right side of search results showing your business name, address, phone number, hours, and star rating. You should fill in the `address`, `telephone`, and `openingHours` fields in the generated output with your actual business details. For restaurants specifically, you can further specify `@type: Restaurant` (a subtype of `LocalBusiness`) by editing the generated block.

How do I add Schema Markup to my WordPress or Wix site?

For WordPress, paste the generated `<script type='application/ld+json'>` block into a custom HTML widget in the page editor, or use the header/footer injection field in a plugin like Insert Headers and Footers. SEO plugins like Yoast SEO and Rank Math also have their own schema editors, but this generator gives you finer control for custom schema not covered by those plugins. For Wix, use the Advanced SEO Settings panel for each page, which has a JSON-LD markup field. On Shopify, add the block to your theme's `theme.liquid` or page template inside the `<head>` tag.

How do I test if my Schema Markup is valid and eligible for rich results?

Google provides two official tools for this. The Rich Results Test (search.google.com/test/rich-results) checks whether your page is eligible for specific rich result features, paste your URL or the generated script block directly and it shows which rich results your schema qualifies for. The Schema Markup Validator (validator.schema.org) checks for structural correctness against the Schema.org vocabulary, flagging missing recommended fields and property type errors. Run both tools after adding schema to confirm validity before indexing.

Can I put multiple schema types on the same page?

Yes, Google supports multiple JSON-LD blocks on a single page and multiple schema types within the same block (using an array). A common pattern is combining `Article` + `BreadcrumbList` on blog posts, or `Product` + `FAQPage` on e-commerce product pages with a FAQ section. Generate each schema type separately using this tool, then paste each `<script>` block individually into the page `<head>`. Alternatively, wrap multiple types in a single script block as a JSON array: `[{...Article...}, {...BreadcrumbList...}]`.

What rich result does FAQPage schema enable in Google Search?

The `FAQPage` schema type enables expandable FAQ accordions directly in Google's search results page. When a user searches a query that matches your page, Google can show your questions and answers as collapsible items directly beneath your main search result listing, significantly expanding the visual space your result occupies on the page. Each `Question` / `acceptedAnswer` pair in the generated JSON-LD becomes one expandable item. You must have at least two valid question-answer pairs for Google to show this feature.

How do I generate schema for a page with multiple FAQ items?

Select `FAQ Page` from the Schema Type dropdown. The generator outputs a starter block with three `Question` / `acceptedAnswer` pairs in the `mainEntity` array. You then edit the generated JSON-LD directly, duplicate the question object block for each additional FAQ item, replacing the `name` property with your question text and the `text` inside `acceptedAnswer` with your answer. Each answer should be a complete sentence (not just a sentence fragment) for Google to display it cleanly in the expandable accordion.

What is BreadcrumbList schema and when should I add it?

A `BreadcrumbList` schema block tells Google the navigational path from your homepage to the current page, for example, Home → Electronics → Smartphones → iPhone 16. When implemented correctly, Google replaces the URL in your search result with this breadcrumb trail (e.g. example.com › electronics › smartphones › iphone-16), which is more descriptive and often improves CTR. Add `BreadcrumbList` to any page that sits more than one level deep in your site hierarchy. It pairs particularly well with category and product pages on e-commerce sites.

Does schema markup work for Indian regional language content?

Yes, Schema.org properties support Unicode, so `name`, `description`, and other text fields can contain Hindi, Tamil, Telugu, Bengali, or any other script. Google processes structured data in all languages it supports for web search. The most impactful schema types for Indian content are `LocalBusiness` (for local search visibility in Google Maps and Search), `Article` (for Top Stories in Google News in regional editions), and `FAQPage` (for voice search answers, which increasingly serve Indian-language queries via Google Assistant).

Also known as

JSON-LD generatorschema.org markup generatorstructured data generatorrich snippet generatorSEO JSON-LD schema

Schema Markup Generator (JSON-LD)