Schema Markup: A Practical Guide with Examples

Schema markup (structured data) is code you add to your pages that helps search engines understand the content and context of your page. It enables rich results — enhanced search listings with stars, images, prices, FAQs, and more. Just as importantly in 2026, the same markup helps AI engines and assistants parse, trust, and cite your content. For a practical hands-on tool, try DarnItSEO's schema markup tester as you follow along, and explore every generator on the schema tools hub.

This guide covers what JSON-LD is and why it is the format to use, the most valuable schema types with copy-paste examples, how to validate your markup, the mistakes that quietly break rich results, and how structured data now does double duty for both Google rich results and AI answers. Bookmark it and use it as a reference while you mark up your own pages.

Why Schema Markup Matters

• Rich results make your listing larger and more eye-catching, which can lift click-through rates significantly.
• It helps search engines understand your content's meaning and relationships, not just its keywords.
• It is required to qualify for many SERP features (recipes, events, products, reviews, FAQs, breadcrumbs).
• It gives AI engines a clean, machine-readable description of your entities, which improves how they parse and cite you. See our LLMO guide for how this connects to AI visibility.
• It strengthens your brand as a recognizable entity through Organization and author markup.

JSON-LD Format

There are three structured data syntaxes — JSON-LD, Microdata, and RDFa — but you should almost always use JSON-LD (JavaScript Object Notation for Linked Data). It is Google's recommended format, it keeps your markup separate from your visible HTML, and it is the easiest to add, edit, and validate. You simply drop a single script tag into the page (the head or body both work):

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "Your Article Title",
  "datePublished": "2026-01-15",
  "author": {
    "@type": "Person",
    "name": "Author Name"
  }
}
</script>

Two fields appear in every block. @context always points to https://schema.org and tells parsers which vocabulary you are using. @type declares what the thing is (Article, Product, Organization, and so on). Everything else is a property of that type. You can also nest types — an Article has an author that is a Person, a Product has an offer that is an Offer — which is how you describe real-world relationships.

Choosing the Right Schema Type

Use this table as a quick map from your page to the schema type and the rich result it can unlock.

Common Schema Types

Article Schema

For blog posts, news articles, and editorial content. Include the headline, dates, author, and publisher with a logo. Generate one quickly with the Article schema generator.

{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "Article Title",
  "description": "Brief description",
  "image": "https://example.com/article-cover.jpg",
  "datePublished": "2026-01-15",
  "dateModified": "2026-01-20",
  "author": {
    "@type": "Person",
    "name": "Author Name",
    "url": "https://example.com/author/author-name"
  },
  "publisher": {
    "@type": "Organization",
    "name": "Publisher Name",
    "logo": {
      "@type": "ImageObject",
      "url": "https://example.com/logo.png"
    }
  }
}

Product Schema

Enables product listings with price, availability, and review stars in search results — one of the highest-impact markups for e-commerce. Nest an Offer for price and stock, and an AggregateRating for stars.

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Wireless Noise-Cancelling Headphones",
  "image": "https://example.com/headphones.jpg",
  "description": "Over-ear headphones with 30-hour battery life.",
  "brand": {
    "@type": "Brand",
    "name": "ExampleAudio"
  },
  "offers": {
    "@type": "Offer",
    "price": "199.00",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock",
    "url": "https://example.com/headphones"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.6",
    "reviewCount": "284"
  }
}

FAQ Schema

Enables expandable FAQ results directly in search and packages your Q&A in exactly the shape AI assistants like to reuse. Only mark up questions and answers that are genuinely visible on the page. Build it with the FAQ schema generator.

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "What is schema markup?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Schema markup is structured data that helps search engines and AI understand your page."
      }
    },
    {
      "@type": "Question",
      "name": "Is JSON-LD better than Microdata?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Yes. JSON-LD is Google's recommended format and is easier to add and maintain."
      }
    }
  ]
}

HowTo Schema

For instructional content. Enables step-by-step rich results with numbered steps and optional images. Each step is a HowToStep with its own name and text.

{
  "@context": "https://schema.org",
  "@type": "HowTo",
  "name": "How to add JSON-LD to a page",
  "step": [
    {
      "@type": "HowToStep",
      "name": "Create the script tag",
      "text": "Add a script tag with type application/ld+json to your page."
    },
    {
      "@type": "HowToStep",
      "name": "Add the schema object",
      "text": "Paste your JSON-LD object inside the script tag."
    },
    {
      "@type": "HowToStep",
      "name": "Validate",
      "text": "Run the page through a validator before publishing."
    }
  ]
}

BreadcrumbList Schema

Shows your site hierarchy in search results, replacing the plain URL with a readable trail. Each level is a ListItem with a position, name, and URL. Generate one with the breadcrumb schema generator.

{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Home",
      "item": "https://example.com/"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Blog",
      "item": "https://example.com/blog"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "Schema Markup Guide",
      "item": "https://example.com/blog/schema-markup-guide"
    }
  ]
}

Organization Schema

Defines your brand as a clear entity: name, logo, official URL, and social profiles. This is the backbone of how both Google and AI engines recognize your company, and it powers knowledge panels. Place it once, site-wide.

{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "Example Company",
  "url": "https://example.com",
  "logo": "https://example.com/logo.png",
  "sameAs": [
    "https://twitter.com/example",
    "https://www.linkedin.com/company/example"
  ]
}

Local Business Schema

Essential for local SEO — enables your business info in Knowledge Panels and Maps. Add address, phone, geo coordinates, and opening hours.

{
  "@context": "https://schema.org",
  "@type": "LocalBusiness",
  "name": "Business Name",
  "image": "https://example.com/storefront.jpg",
  "address": {
    "@type": "PostalAddress",
    "streetAddress": "123 Main St",
    "addressLocality": "City",
    "addressRegion": "State",
    "postalCode": "12345",
    "addressCountry": "US"
  },
  "telephone": "+1-555-555-5555",
  "openingHoursSpecification": [
    {
      "@type": "OpeningHoursSpecification",
      "dayOfWeek": ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"],
      "opens": "09:00",
      "closes": "17:00"
    }
  ]
}

Review and AggregateRating Schema

Star ratings are among the most clicked rich results. Use Review for a single review and AggregateRating to summarize many. Attach them to the thing being reviewed (a Product, LocalBusiness, etc.), and never invent ratings — Google penalizes fabricated review markup.

{
  "@context": "https://schema.org",
  "@type": "Review",
  "itemReviewed": {
    "@type": "Product",
    "name": "Wireless Noise-Cancelling Headphones"
  },
  "reviewRating": {
    "@type": "Rating",
    "ratingValue": "5",
    "bestRating": "5"
  },
  "author": {
    "@type": "Person",
    "name": "Jordan Lee"
  },
  "reviewBody": "Excellent sound and battery life."
}

Where to Put Your Schema and How Engines Read It

A frequent source of confusion is where the JSON-LD should live and how engines actually consume it. The good news is JSON-LD is forgiving. You can place the script tag in the head or anywhere in the body, and search engines will find and parse it either way. Because the markup is separate from your visible HTML, it does not affect how the page looks to users, which is a big reason JSON-LD is preferred over inline Microdata.

A few practical points worth knowing as you implement:

• One thing, described once. Describe each real-world entity a single time and reference it elsewhere by its identifier, rather than repeating the same Organization object on every page. This keeps your markup consistent and easy to maintain.
• Match the visible page. Every value in your schema should correspond to something a user can actually see and verify on the page. Engines cross-check this, and mismatches erode trust in all your markup.
• Render it server-side when possible. If your schema is injected only by client-side JavaScript, some crawlers and AI fetchers may miss it. Server-rendering or static generation guarantees the markup is present in the raw HTML every fetcher sees.
• Keep it valid JSON. A stray trailing comma or unescaped quote can invalidate the entire block. This is exactly what validators catch, which is why you run them before every publish.
• Do not gate it behind interaction. Schema describing content that only appears after a click (a hidden tab or modal) can be treated as not visible. Make sure the underlying content is genuinely on the page.

Once you internalize "describe what is really on the page, in valid JSON, present in the raw HTML," most schema problems disappear. From there it is about choosing the right types and keeping them in sync with your data.

How Schema Helps Both Rich Results and AI

For years, structured data was a Google rich-results play. In 2026 it does double duty. The same JSON-LD that earns you stars and FAQs in search also gives large language models an unambiguous description of your entities and facts. When an AI assistant reads your page, your Organization block tells it exactly who you are, your Article block confirms authorship and dates (an E-E-A-T signal), and your FAQPage block hands it ready-made question-and-answer pairs to quote. Structured data reduces the model's uncertainty, which makes it more willing to cite you and less likely to get your facts wrong. To go deeper on the AI side, read our LLMO guide and the AEO guide, and check whether your pages qualify for AI answers with the AI Overviews eligibility tool.

WebSite and SearchAction Schema

Two site-wide markups round out a strong setup. WebSite schema names your site as an entity and ties it to your organization, and the SearchAction inside it can enable a search box directly under your listing in some results. Place this once, alongside your Organization block, on your homepage.

{
  "@context": "https://schema.org",
  "@type": "WebSite",
  "name": "Example Company",
  "url": "https://example.com",
  "potentialAction": {
    "@type": "SearchAction",
    "target": "https://example.com/search?q={search_term}",
    "query-input": "required name=search_term"
  }
}

Combined with Organization and BreadcrumbList, WebSite schema gives engines and AI a clear top-level picture of your site: who runs it, how it is structured, and how to search it. That clarity is exactly what helps you show up as a confident, well-understood entity rather than a loose collection of pages.

Required vs Recommended Properties

Every rich result type has properties Google treats as required (omit them and you are ineligible) and others that are recommended (they improve the result but are not mandatory). A common reason schema "does not work" is a missing required field, not bad syntax. Here is a quick reference for the most common types.

When in doubt, build the block with the matching generator on the schema tools hub — the Article, FAQ, and breadcrumb generators include the required fields by default — then confirm eligibility before publishing.

Validation

Never publish schema you have not validated — a single malformed field can disqualify the whole block from rich results. Always check your markup with:

• Google Rich Results Test — Tests whether your page is eligible for specific rich results and previews how they may appear.
• Schema.org Validator — Checks raw syntax and vocabulary correctness, independent of Google's eligibility rules.
• DarnItSEO's JSON-LD validator and schema markup tester — Build, lint, and validate structured data with an easy-to-use visual tool, then run a full site audit to find every page that is missing or breaking schema.

Common Mistakes

• Marking up invisible content. Schema must reflect content actually present on the page. FAQ or review markup for content users cannot see is a guidelines violation and can earn a manual penalty.
• Using the wrong type. Tagging a product page as Article, or a category page as Product, confuses parsers and forfeits rich results.
• Missing required fields. Each rich result has required and recommended properties; omitting a required one (like an author for Article, or price for Offer) blocks eligibility.
• Duplicate or conflicting schema. Two different Organization blocks, or contradictory dates across blocks, make engines distrust all of it.
• Fabricated ratings. Inventing star ratings or self-serving reviews risks a structured data penalty.
• Forgetting to update dates. Stale dateModified values undercut the freshness signal you are trying to send.
• Not re-validating after changes. A template edit can silently break markup site-wide; re-test after any change. For broader fixes, see our technical SEO checklist and what is SEO for fundamentals.

Implementation Tips

• One source of truth. Generate schema from your real page data (CMS fields, product database) so it never drifts out of sync with what users see.
• Keep it in the template. Add schema in your page template so every post, product, or location gets it automatically and consistently.
• Start with the highest-impact types. For most sites that is Organization site-wide, then Article on the blog, Product on shop pages, and BreadcrumbList everywhere.
• Use the generators, then validate. Save time with the Article, FAQ, and breadcrumb generators, and confirm each block with the JSON-LD validator.
• Monitor over time. Track which pages carry valid schema and which rich results you have earned from your dashboard. Paid plans add automated, scheduled schema monitoring across your whole site.

Connecting Your Schema with @id and sameAs

Individual schema blocks are useful on their own, but the real power of structured data comes from connecting them into a graph that engines and AI can follow. Two properties do most of this work.

• @id gives an entity a stable, unique identifier (usually a URL with a fragment) so you can reference the same thing from multiple blocks instead of redefining it. For example, define your Organization once with an @id, then point your Article's publisher at that @id rather than repeating the whole organization object.
• sameAs links your entity to its authoritative profiles elsewhere — your Wikipedia page, Wikidata entry, LinkedIn, X, and Crunchbase. These links help engines and AI confirm that your brand is the same entity referenced across the web, which strengthens recognition and trust.

{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "Schema Markup Guide",
  "publisher": { "@id": "https://example.com/#organization" }
}

{
  "@context": "https://schema.org",
  "@type": "Organization",
  "@id": "https://example.com/#organization",
  "name": "Example Company",
  "url": "https://example.com",
  "sameAs": [
    "https://en.wikipedia.org/wiki/Example_Company",
    "https://www.linkedin.com/company/example"
  ]
}

Wiring your entities together this way is one of the most underused tactics in structured data, and it pays off for both traditional knowledge panels and AI entity recognition. For more on the AI side, see our LLMO guide and the AEO guide.

Maintaining Schema at Scale

Adding schema is the easy part; keeping it accurate as your site grows is where most teams slip. A few habits keep your structured data healthy over the long run.

• Drive it from data, not hand-editing. Generate each block from your CMS fields or product database so prices, dates, and ratings always match what users see. Hand-maintained JSON drifts out of sync fast.
• Centralize in templates. Put schema in shared page templates so a single fix propagates everywhere — and so a single bug does too, which is why you re-validate after template changes.
• Watch for stale dates and prices. Outdated dateModified values weaken freshness signals, and mismatched prices can trigger structured data warnings. Automate these from source data.
• Audit the whole site regularly. Spot-checking a few pages misses systemic breakage. Run a full audit to catch every page that is missing schema, has invalid markup, or carries the wrong type.
• Track coverage over time. Monitor which pages carry valid schema and which rich results you have earned from your dashboard; paid plans add scheduled, automated schema monitoring across your whole site so regressions surface before they cost you results.

Treat structured data as living infrastructure, not a one-off task, and it will keep paying off in both rich results and AI citations. Explore every builder and checker on the schema tools hub whenever you add a new page type.

Frequently Asked Questions

What is schema markup in simple terms?

Schema markup is a small block of code, written in JSON-LD, that labels what your page is about — for example "this is a product, here is its price, and it has a 4.6-star rating." Search engines and AI use those labels to display richer results and to understand and cite your content more accurately.

Does schema markup improve rankings directly?

Schema is not a direct ranking factor, but it is highly worthwhile. It unlocks rich results that increase click-through rate, and it helps engines and AI understand your content, which indirectly supports visibility. Think of it as eligibility and clarity rather than a ranking boost on its own.

Which schema format should I use — JSON-LD, Microdata, or RDFa?

Use JSON-LD. It is Google's recommended format, keeps the markup separate from your visible HTML, and is the easiest to add and maintain. Microdata and RDFa still work but are harder to manage and offer no real advantage. Our JSON-LD validator makes it easy to get right.

Will schema markup help with AI search and ChatGPT-style answers?

Yes. Structured data gives language models a clean, unambiguous description of your entities and facts, which makes them more confident quoting you and less likely to get details wrong. Organization, Article, and FAQPage markup are especially useful here. See our LLMO guide for the full picture.

Can I add multiple schema types to one page?

Yes, and you often should — for example a blog post can carry Article, BreadcrumbList, and FAQPage markup together. Just make sure each block is accurate, non-contradictory, and reflects content visible on the page. Validate the page as a whole after adding them.

How do I test if my schema is working?

Run the page through Google's Rich Results Test for eligibility, the Schema.org Validator for syntax, and DarnItSEO's schema markup tester to build and lint it visually. For site-wide coverage, a full audit flags every page that is missing or breaking structured data.

What happens if my schema has an error?

A single invalid or missing required field can disqualify that block from rich results, even if the rest is fine. Errors do not usually harm rankings, but they waste the opportunity. Always validate before publishing and re-test after any template change, since one edit can break markup across many pages.