Home›Generators›Developer Tools›Schema Markup Generator (JSON-LD)

Schema Markup Generator (JSON-LD)

Developer Tools

Generate JSON-LD structured data for Article, FAQ, LocalBusiness, Product, HowTo, and more. Copy the script block into your HTML <head> for rich search results.

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.

How to use this Schema Markup calculator

  1. 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.
  2. 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.
  3. 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.
  4. Enter the canonical URL of the page — the full absolute URL including https://, matching the <link rel="canonical"> in your <head>.
  5. 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.
  6. Enter the Date Published in YYYY-MM-DD format (e.g. 2026-01-15). Required for Article schema to qualify for Top Stories.
  7. 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.
  8. Review the JSON-LD Script Block output panel — the complete <script type="application/ld+json"> block appears here, formatted for readability.
  9. 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.
  10. 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.

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

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.
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.
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.
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.
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.
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.
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.
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...}]`.
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.
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.
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.
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