What Is Schema Markup? A Beginner's Guide to Adding It
Schema markup is structured data that tells search engines and AI what a page is about. What it does, which types to start with, and how to add and test it.
Kazi Khalid Hasan Tamim · BugViso Team
16 min read
Schema markup is structured data, usually written as JSON-LD in a <script> tag, that labels what a page is about: a product, an article, an organization, a local business.
Search engines and AI answer engines read those labels to identify the entities on the page. Google uses some types to show rich results such as review stars, prices and event dates.
When a search engine reads "Apple" on your page, it doesn't know if you mean the fruit, the company or a surname.
Schema markup removes that ambiguity by declaring "this is a Product with a price of $49.99" or "this is an Organization with these official profiles". That is the whole idea behind structured data for SEO: you state the facts instead of making a crawler infer them.
Think of schema markup as nutrition labels for your website. A nutrition label doesn't change what's inside the food — it gives consumers (and regulators) a structured, machine-readable summary of what's there.
Schema markup does the same for search engines: it doesn't change your visible content, but it provides a structured summary that machines can parse instantly instead of guessing.
What Is Schema Markup? A Worked Example
Schema markup is written in a format called JSON-LD (JavaScript Object Notation for Linked Data), which lives inside a <script> tag in your HTML. It's invisible to visitors — only machines read it:
<!-- This is schema markup — visitors never see it -->
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "LocalBusiness",
"name": "Downtown Coffee Roasters",
"address": {
"@type": "PostalAddress",
"streetAddress": "123 Main Street",
"addressLocality": "Portland",
"addressRegion": "OR",
"postalCode": "97201"
},
"telephone": "+1-503-555-0123",
"openingHours": "Mo-Fr 06:00-18:00",
"priceRange": "$$"
}
</script>This block tells Google: "This page is about a local business named Downtown Coffee Roasters, located at 123 Main Street, Portland, OR, open Monday–Friday 6am–6pm, with moderate pricing."
Without this markup, Google would need to parse your entire page text, infer the business name from context, and guess at the address format. That process is error-prone and often incomplete.
Does Schema Markup Help SEO in 2026?
Yes, indirectly. Google says structured data is not a ranking factor. It does make pages eligible for rich results, helps Google understand the entities on a page, and gives AI engines unambiguous facts to quote.
The benefit is a better listing and cleaner entity data, not a rankings boost.
Rich Results in Search
Pages with valid schema markup can qualify for rich results: enhanced listings with star ratings, prices, event dates or recipe details.
Google has been trimming the list. This is where each common type stood when we checked Google's Search Central changelog on 2026-11-05:
| Rich Result Type | Required Schema | Status in Google Search |
|---|---|---|
| Review stars | Product, AggregateRating | Supported. See AggregateRating schema for review stars |
| FAQ accordion | FAQPage, Question, Answer | No longer shown since May 7, 2026 |
| Recipe card | Recipe (image, cook time, nutrition) | Supported |
| Event listing | Event (date, location, offers) | Supported |
| Breadcrumbs | BreadcrumbList | Supported. See BreadcrumbList JSON-LD |
| Sitelinks search box | WebSite, SearchAction | Retired in November 2024 |
Whether a rich result lifts clicks is a separate question; our guide on whether rich snippets increase click-through rate covers what published data shows. To see which types still earn a rich result and which properties each needs, read how to get rich snippets with schema markup.
AI Search Engine Citations
Generative AI answer engines (ChatGPT Search, Perplexity, Google AI Overviews) have not published how much weight they give schema markup. It still makes your facts unambiguous: explicit schema states names, prices and relationships that a parser would otherwise infer from paragraphs.
The details are in schema markup for AI search. Pair it with strong content extractability signals in the visible text.
Knowledge Graph Connections
Schema markup creates explicit entity relationships that feed Google's Knowledge Graph. An Organization schema with sameAs links to your social profiles connects your brand entity across platforms.
A Person schema for your author with alumniOf, jobTitle, and worksFor properties gives readers and machines a verifiable author. The setup is covered in author schema markup with Article and Person JSON-LD.
Five Schema Types to Start With
Each block below is a working JSON-LD template. More page types, including Product, FAQ, LocalBusiness and Event, are in the JSON-LD template library.
1. Organization Schema (Every Business Website)
This establishes your brand entity in Google's Knowledge Graph:
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "Organization",
"name": "Your Company Name",
"url": "https://example.com",
"logo": "https://example.com/logo.png",
"description": "Brief description of your business.",
"foundingDate": "2020",
"sameAs": [
"https://twitter.com/yourcompany",
"https://linkedin.com/company/yourcompany",
"https://github.com/yourcompany"
],
"contactPoint": {
"@type": "ContactPoint",
"telephone": "+1-555-123-4567",
"contactType": "customer service",
"email": "support@example.com"
}
}
</script>Where to place it: Your homepage. One instance per site is sufficient — don't repeat it on every page.
2. WebSite Schema (Site Name)
WebSite markup tells Google your site's name and homepage URL, which feeds the site name shown in results.
Older guides add a SearchAction here to get a sitelinks search box. Google retired that feature in November 2024, so skip it:
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "WebSite",
"name": "Your Company Name",
"alternateName": "YourCo",
"url": "https://example.com"
}
</script>Where to place it: Your homepage only.
3. BreadcrumbList Schema (Every Interior Page)
Breadcrumbs show the page's position in your site hierarchy directly in Google results. For a deeper look, see the BreadcrumbList implementation guide and, for stores, breadcrumb navigation for ecommerce SEO:
<!-- Page: /products/electronics/headphones -->
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "BreadcrumbList",
"itemListElement": [
{
"@type": "ListItem",
"position": 1,
"name": "Home",
"item": "https://example.com"
},
{
"@type": "ListItem",
"position": 2,
"name": "Products",
"item": "https://example.com/products"
},
{
"@type": "ListItem",
"position": 3,
"name": "Electronics",
"item": "https://example.com/products/electronics"
},
{
"@type": "ListItem",
"position": 4,
"name": "Headphones"
}
]
}
</script>Where to place it: Every page that has a hierarchical position (everything except the homepage).
4. Article Schema (Blog Posts and Content Pages)
This labels the headline, dates and author of a content page, which helps machines attribute it correctly:
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "Article",
"headline": "How to Optimize Images for Web Performance",
"description": "Complete guide to image optimization...",
"image": "https://example.com/images/hero-image-optimization.webp",
"author": {
"@type": "Person",
"name": "Sarah Chen",
"url": "https://example.com/team/sarah-chen",
"jobTitle": "Senior Performance Engineer"
},
"publisher": {
"@type": "Organization",
"name": "Your Company Name",
"logo": {
"@type": "ImageObject",
"url": "https://example.com/logo.png"
}
},
"datePublished": "2026-09-15T00:00:00.000Z",
"dateModified": "2026-09-18T00:00:00.000Z",
"mainEntityOfPage": "https://example.com/blog/image-optimization-guide"
}
</script>Where to place it: Every blog post, news article, or long-form content page.
5. FAQPage Schema (Optional, No Google Rich Result)
Google stopped showing FAQ rich results on May 7, 2026, so FAQPage no longer earns an accordion in Google Search. The markup is still valid schema.org, and it states question-and-answer pairs explicitly for any parser that reads it.
Treat it as optional. The FAQPage schema guide covers when it is still worth adding, and QAPage versus FAQPage covers forum and support pages:
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "FAQPage",
"mainEntity": [
{
"@type": "Question",
"name": "What is schema markup?",
"acceptedAnswer": {
"@type": "Answer",
"text": "Schema markup is a standardized vocabulary of HTML tags that helps search engines understand the meaning of your content. It uses the Schema.org vocabulary to describe entities like products, articles, events, and organizations in a machine-readable format."
}
},
{
"@type": "Question",
"name": "Does schema markup improve rankings?",
"acceptedAnswer": {
"@type": "Answer",
"text": "Schema markup is not a direct ranking factor. It helps search engines understand a page and can make it eligible for rich results, which change how the listing looks."
}
}
]
}
</script>Where to place it: Pages whose visible content is question-and-answer pairs. The questions and answers must appear on the page itself.
How to Add Schema Markup to Your Site (Step by Step)
Step 1: Identify Your Page Type
Match each page type on your site to the appropriate schema:
| Page Type | Primary Schema | Optional Schema |
|---|---|---|
| Homepage | Organization, WebSite | sameAs profile links |
| Product page | Product, AggregateRating, Offer | BreadcrumbList |
| Blog post | Article, BreadcrumbList | FAQPage (if FAQ section exists) |
| Service page | Service, BreadcrumbList | FAQPage |
| Contact page | ContactPage, LocalBusiness | PostalAddress |
| About page | AboutPage, Person/Organization | sameAs social links |
| Event page | Event, BreadcrumbList | Offer, Place |
Step 2: Write or Generate the JSON-LD
You can write JSON-LD manually (it's standard JSON with a few special keys), or start from a template in the JSON-LD template library. Adding it by hand is straightforward once you know the format; the JSON-LD vs Microdata vs RDFa comparison explains why JSON-LD is the default.
Building it from CMS data in code? See automating JSON-LD in Next.js and a headless CMS.
The required keys in every JSON-LD block:
{
"@context": "https://schema.org",
"@type": "Product",
"name": "Required: the entity name",
"description": "Recommended: brief description"
}@context— Always"https://schema.org"— declares the vocabulary@type— The entity type from the Schema.org hierarchy- Properties — Type-specific fields (varies by
@type)
Step 3: Add the Script Tag to Your HTML
Place the JSON-LD <script> tag inside the <head> or at the end of <body>. Google accepts both positions:
<head>
<title>Widget Pro — Example Store</title>
<!-- Schema markup in the head -->
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "Product",
"name": "Widget Pro",
"description": "Premium widget with advanced features.",
"offers": {
"@type": "Offer",
"price": "49.99",
"priceCurrency": "USD",
"availability": "https://schema.org/InStock"
}
}
</script>
</head>For CMS platforms without direct HTML access:
- WordPress: Use a plugin like Yoast SEO or Rank Math which generates schema automatically
- Shopify: Product schema is auto-generated by most themes; add custom schema via
theme.liquid - Squarespace: Built-in schema for basic types; custom JSON-LD via Code Injection
- Next.js/React: Inject via
<Head>component ormetadata.otherin the App Router
Step 4: Validate Your Markup
After adding schema, validate it with two tools. The full routine is in the 15-step schema validation checklist:
# Tool 1: Google's Rich Results Test
# https://search.google.com/test/rich-results
# Tests whether your schema qualifies for specific rich result types
# Tool 2: Schema.org Validator
# https://validator.schema.org/
# Validates JSON-LD syntax and property completenessCommon validation errors:
| Error | Cause | Fix |
|---|---|---|
| Missing required property | E.g., Product without offers | Add the missing property |
Invalid @type | Typo in type name (e.g., "Artcle") | Check spelling against Schema.org |
Invalid URL in image | Relative path instead of absolute URL | Use full https:// URL |
| JSON syntax error | Trailing comma, unquoted key | Run through a JSON linter |
| Mismatched content | Schema says "In Stock" but page says "Sold Out" | Keep schema and visible content in sync |
Step 5: Monitor Rich Results in Google Search Console
After validation, monitor GSC → Enhancements to track which rich result types Google detects on your site and whether any pages have errors:
- Valid items: Pages with correct schema that qualify for rich results
- Valid with warnings: Pages with schema that works but has optional fields missing
- Errors: Pages with schema that Google cannot process. If you see "Unparsable structured data", follow how to fix unparsable structured data errors
Common Mistakes Beginners Make
Beginners make five common schema mistakes: markup that does not match the page, over-marking content, schema on the wrong pages, Microdata instead of JSON-LD, and a dateModified that changes on every load. Each is explained below.
Mistake 1: Adding schema that doesn't match visible content. Google's structured data guidelines require that schema markup accurately represents the content visible on the page. Adding a Product schema with a price of "$29.99" when the visible page shows "$39.99" violates Google's policies and can result in a manual action (penalty).
Mistake 2: Over-marking content with irrelevant schema. A blog post about "how to bake bread" doesn't need Product or Organization schema.
Match the schema type to the page's actual content purpose. Using inappropriate schema types doesn't help rankings and may trigger quality review.
Mistake 3: Placing schema on pages it shouldn't apply to. FAQPage schema should only appear on pages that are primarily an FAQ, not on every product page that happens to have one question in the footer.
Google no longer shows FAQ rich results at all, so there is nothing to gain from stretching it onto other pages.
Mistake 4: Using Microdata instead of JSON-LD. While Google supports both formats, JSON-LD is Google's explicitly preferred format because it's decoupled from the HTML. You can add, modify or remove schema without touching the page template.
Microdata requires inline attributes on HTML elements, making it harder to maintain and test.
Mistake 5: Setting dateModified to the current date on every page load. Dynamic dateModified timestamps that update to "today" on every request misstate when the content changed. Only update dateModified when the page content has genuinely been revised.
How BugViso Validates Your Schema Markup Automatically
BugViso's structured data check audits the JSON-LD on every page crawled when you sign in and run a multi-page site scan.
The validator extracts inline application/ld+json blocks (including @graph containers with multiple entities). It then validates them against common landing-page types: Organization, Product, SoftwareApplication, WebSite and more.
It flags missing required properties (like offers.price and priceCurrency on product pages), malformed JSON-LD syntax, and pages with pricing sections that lack matching commerce schema.
For pages with FAQ and Q&A content, BugViso's AI Search Readiness engine evaluates content extractability.
It checks whether question-style headings, list and table structures, and summary blocks are present alongside any FAQPage or QAPage schema. Together these checks show where a page has the content but lacks matching schema.
For the full list of what BugViso tests here, see the technical SEO audit tool.
Schema Types for Specific Business Contexts
E-Commerce: Product + Offer + AggregateRating
Review stars have eligibility rules of their own; read Product AggregateRating schema before copying this block.
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "Product",
"name": "Wireless Noise-Canceling Headphones",
"image": "https://example.com/images/headphones-hero.webp",
"description": "Premium wireless headphones with active noise cancellation.",
"brand": {
"@type": "Brand",
"name": "AudioTech"
},
"offers": {
"@type": "Offer",
"price": "149.99",
"priceCurrency": "USD",
"availability": "https://schema.org/InStock",
"url": "https://example.com/products/wireless-headphones",
"priceValidUntil": "2027-01-01"
},
"aggregateRating": {
"@type": "AggregateRating",
"ratingValue": "4.6",
"reviewCount": "342"
}
}
</script>SaaS / Software: SoftwareApplication
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "SoftwareApplication",
"name": "Example Audit Tool",
"applicationCategory": "WebApplication",
"operatingSystem": "Web",
"description": "Website audit tool for SEO, performance, and accessibility.",
"offers": {
"@type": "Offer",
"price": "49",
"priceCurrency": "USD"
}
}
</script>Local Business: LocalBusiness + GeoCoordinates
For more than one branch, follow LocalBusiness schema for multiple locations.
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "Restaurant",
"name": "Fresh Kitchen Downtown",
"image": "https://example.com/images/restaurant-exterior.webp",
"address": {
"@type": "PostalAddress",
"streetAddress": "456 Oak Avenue",
"addressLocality": "San Francisco",
"addressRegion": "CA",
"postalCode": "94102",
"addressCountry": "US"
},
"geo": {
"@type": "GeoCoordinates",
"latitude": 37.7749,
"longitude": -122.4194
},
"telephone": "+1-415-555-0199",
"servesCuisine": "Farm-to-table American",
"priceRange": "$$$",
"openingHoursSpecification": [
{
"@type": "OpeningHoursSpecification",
"dayOfWeek": ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"],
"opens": "11:00",
"closes": "22:00"
},
{
"@type": "OpeningHoursSpecification",
"dayOfWeek": ["Saturday", "Sunday"],
"opens": "09:00",
"closes": "23:00"
}
]
}
</script>Frequently Asked Questions
Is schema markup a direct ranking factor?
No. Google has stated that structured data is not a direct ranking signal. Schema makes pages eligible for rich results and helps Google understand the entities on a page.
Its value is in how the listing looks and how clearly machines read the page.
How many schema types can I put on one page?
Multiple. A product page can have Product, BreadcrumbList, and Organization schema simultaneously. Use the @graph container to bundle multiple entities in a single JSON-LD block:
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@graph": [
{ "@type": "Product", "name": "Widget Pro", ... },
{ "@type": "BreadcrumbList", "itemListElement": [...] },
{ "@type": "Organization", "name": "Example Corp", ... }
]
}
</script>Do I need schema on every page?
Not necessarily. Prioritize pages that can qualify for rich results or carry key entity facts.
Those are product pages (price and review stars), blog posts (author and dates), interior pages (breadcrumbs) and your homepage (Organization and site name). Pages like privacy policies, terms of service, and login screens generally don't benefit from schema.
Will Google penalize me for incorrect schema?
Google won't penalize you for honest mistakes in schema syntax.
However, spammy or misleading schema (fake reviews, fabricated prices, marking non-FAQ content as FAQPage) can result in a manual action that removes rich results from your entire site. Always ensure schema accurately reflects visible content.
What's the difference between JSON-LD, Microdata, and RDFa?
All three are formats for embedding structured data.
JSON-LD is a script block in your <head> or <body> and is Google's recommended format. Microdata uses inline HTML attributes (itemscope, itemprop). RDFa uses typeof and property attributes.
JSON-LD is preferred because it's decoupled from your HTML template, making it easier to implement and test without modifying page markup.
How do I add schema to a WordPress site without coding?
Use an SEO plugin (Yoast SEO, Rank Math, or All in One SEO) that generates schema automatically based on your content type. These plugins add Article schema to posts, WebSite/Organization schema to the homepage, and allow custom schema through their settings UI — no code editing required.
Related Schema Guides
These guides cover related schema types and uses in more depth.
- Underused schema types most sites skip: Organization
sameAs, ItemList and other types worth adding. - VideoObject schema for video thumbnails: required properties and how to check video indexing.
- Structured data for generative AI engines: how AI engines read JSON-LD and how to test what they see.
Where to Go Next
Schema markup is the bridge between human-readable content and machine-readable entities. Start with Organization, WebSite and BreadcrumbList, add the type that matches each page, then validate.
Sign in and run a BugViso scan to check that your markup is syntactically correct and complete on every page the crawl reaches.
Written by
Kazi Khalid Hasan Tamim · BugViso Team
Kazi writes BugViso’s guides on website audits, Core Web Vitals, technical SEO, accessibility and AI search. The data in them comes from audits BugViso runs in a real Chromium browser, including our 219-site study of website health.
Summarise with AI
Open this guide in your assistant.
Follow BugViso
New guides and audit data as we publish them.
AI visibility tracker
Is your brand in AI answers?
See how often AI assistants mention you, cite your site and rank you against your competitors.
- ChatGPT
- Gemini
- Perplexity
- Claude
- AI Overviews
See where your site stands
Run a free BugViso audit for SEO, speed, accessibility and AI search readiness — with fixes you can ship today.