How to Add Schema Markup: JSON-LD and Structured Data

Q: What's Next?

Start with one template, not one random page. Add clean Article or BreadcrumbList markup, validate it, deploy it, and then inspect the rendered HTML. Structured data is boring when it works, which is exactly what you want.

Search engines can read a page, but they still benefit from explicit clues. Is "Avatar" a movie, a brand, or a profile picture? Is that number a price, a rating, or a phone extension? Schema markup gives those clues in a structured format that machines can parse without guessing.

The payoff is eligibility. Structured data can make a page eligible for rich results such as product details, recipe cards, event listings, breadcrumbs, or article enhancements. It does not guarantee a special result, and it should never describe content that users cannot see on the page.

Quick Answer

Use JSON-LD schema when it describes the main visible content of a page. Start with Article or BlogPosting for posts, Product for real product pages, BreadcrumbList for navigation paths, and Organization or WebSite for site identity. Generate the markup, place it in the page template, test it with Google's Rich Results Test, and monitor Search Console after deployment.

The safest rule: if a claim is in your structured data, the same claim should be visible to the reader on that page.

Quick Answer
The Building Blocks: Schema.org and JSON-LD
Which Schema Types Are Worth Your Time
Adding Markup Step by Step
Common Mistakes That Cost Rich Results
A Worked Example: FAQ Markup
Does Schema Help SEO? An Honest Answer
Rollout Checklist
What's Next

The Building Blocks: Schema.org and JSON-LD

Two names cover the whole topic:

Schema.org is the vocabulary: a catalog of types (Article, Product, Recipe, Event, FAQPage, LocalBusiness, and hundreds more) and their properties (name, datePublished, price, calories). It is maintained jointly by Google, Microsoft, Yahoo, and Yandex, so one vocabulary serves all major engines.

JSON-LD is the format: a block of JSON placed inside a <script type="application/ld+json"> tag, usually in the page head. Google explicitly recommends JSON-LD over the older formats (Microdata and RDFa attributes woven into your HTML), and for good reason: it keeps the structured data in one tidy block, separate from your markup, where it is easy to generate, review, and update.

Here is a complete, valid example for an article:

JSON

{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "How to Add Schema Markup to Your Website",
  "description": "Structured data explained step by step.",
  "datePublished": "2026-05-21",
  "author": {
    "@type": "Person",
    "name": "Jane Doe"
  },
  "publisher": {
    "@type": "Organization",
    "name": "BuildQuill",
    "url": "https://buildquill.com"
  }
}

Reading it top to bottom: @context declares the vocabulary, @type picks the type, and the rest are properties from that type's catalog. Values can be nested objects with their own @type, like the author above.

Which Schema Types Are Worth Your Time

There are over 800 types, but Google only generates rich results for a few dozen, and only a handful apply to most sites. Prioritize by what your pages actually are:

Article / BlogPosting: for editorial content. Feeds headline and image into Discover and news surfaces.
Product with Offer and AggregateRating: the big one for e-commerce. Price, availability, and review stars directly in the snippet.
LocalBusiness: address, hours, phone. Essential for anything with a physical location; feeds the map pack.
FAQPage: question-answer pairs for pages with a genuine FAQ section. Google shows FAQ rich results only in limited cases, so use it for clarity, not as a guaranteed SERP feature.
HowTo: step-by-step instructions with optional images per step.
Recipe: cooking time, calories, ratings, photo. Non-negotiable for food sites.
Event: dates, venue, ticket availability.
BreadcrumbList: replaces the raw URL in your snippet with a readable path. Applies to almost every site and is one of the easiest wins.
Organization / WebSite: identity markup for your brand; helps knowledge panels and sitelinks.

If your page type is not on Google's supported list, markup can still help engines understand entities and relationships, but do not expect a visual rich result from it.

Adding Markup Step by Step

Step 1: Pick the type that matches the page's main content

The markup must describe what the page is primarily about, not everything on it. A product page gets Product markup; do not also stamp it FAQPage because the footer has two questions. Google penalizes markup that misrepresents page content.

Step 2: Generate the JSON-LD

You can write it by hand from the schema.org reference, but a generator is faster and avoids typos in property names. Our Schema Markup Generator builds valid JSON-LD for the common types from a simple form. Fill in every recommended property you honestly can: more complete markup is more likely to earn the rich treatment.

Two rules while filling values:

Values must match the visible page. The price in your markup must be the price on the page. The ratings must be real user ratings shown on the page. Invisible or inflated data is the classic path to a manual penalty.
Dates and formats matter. Dates in ISO 8601 (2026-05-21), durations in ISO 8601 duration format (PT30M for 30 minutes), prices as numbers with a separate priceCurrency.

Step 3: Place it in the page

Paste the <script type="application/ld+json"> block into the page's <head> (or body; both work, head is conventional). In a CMS, use your SEO plugin's schema fields or a template-level injection so every article or product gets markup automatically. Hand-pasting into individual pages does not scale and rots quickly.

If you are unsure your JSON survived the templating intact, validate the syntax with our JSON Formatter first; a single unescaped quote from a product name like 6" pipe will silently kill the whole block.

Step 4: Test before and after deploying

Two official tools:

Rich Results Test (search.google.com/test/rich-results): paste a URL or code snippet; it reports which rich results the page is eligible for, plus errors and warnings.
Schema Markup Validator (validator.schema.org): checks the markup against the vocabulary itself, catching property typos and type mismatches beyond Google's subset.

Errors block eligibility and must be fixed. Warnings are recommended-but-missing properties; fill what you can. After deploying, Search Console's "Enhancements" section tracks your structured data sitewide and emails you when new errors appear.

Common Mistakes That Cost Rich Results

Marking up content that is not there. The number one cause of structured data manual actions. Every marked-up claim must be visible to users on that page.

Review stars on self-serving content. Google ignores AggregateRating markup where the site rates itself (LocalBusiness or Organization rating themselves). Ratings must come from users about a distinct thing.

Duplicate conflicting blocks. CMS plugins sometimes each inject their own Organization or WebSite markup with different values. Audit what your pages actually output; one source of truth per type.

Missing required properties. Each rich result type has required fields (a Product offer needs price and availability; a Recipe needs name and image). The Rich Results Test flags these explicitly.

Forgetting to update markup when content changes. A price change that updates the page but not the markup creates a mismatch that erodes trust. This is why template-generated markup beats hand-pasted blocks.

Expecting guaranteed results. Valid markup makes you eligible; Google decides per query whether to show the rich treatment. New markup typically takes days to weeks to appear, and can come and go. This is normal, not a bug in your implementation.

A Worked Example: FAQ Markup

Say your article ends with two genuine questions. The markup:

JSON

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "Does schema markup improve rankings?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Not directly. It makes results richer and more clickable, and higher click-through can improve performance over time."
      }
    },
    {
      "@type": "Question",
      "name": "How long until rich results appear?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Typically days to a few weeks after Google recrawls the page, if the page is eligible."
      }
    }
  ]
}

The pattern generalizes: a type, a mainEntity or equivalent container, and nested typed objects. Once you have read one example, the schema.org reference pages become easy to navigate.

Does Schema Help SEO? An Honest Answer

Structured data is not a direct ranking factor, and Google says so plainly. What it does:

Can increase snippet real estate and click-through rate. Stars, prices, breadcrumbs, and other rich elements can draw the eye when Google chooses to show them.
Improves understanding. Explicit entities help engines match your page to relevant queries, which matters most for ambiguous or entity-heavy content.
Feeds other surfaces. Discover, Shopping, voice assistants, and AI-generated answers all consume structured data.

So the honest pitch: schema markup is a machine-comprehension and search-appearance investment. For most sites, the few hours it takes to add Article or Product plus BreadcrumbList markup via templates is among the best-value technical SEO work available.

Rollout Checklist

Inventory your page templates and map each to a schema type
Start with BreadcrumbList sitewide plus your main content type
Generate JSON-LD with the Schema Markup Generator, filling all recommended fields honestly
Inject via template, not by hand
Validate with the Rich Results Test before deploying
Monitor Search Console Enhancements for errors after deploying
Revisit quarterly: new schema types get supported, and old markup drifts from content

Treat structured data as part of the page, maintained with the page, and it will quietly compound into more visible, more clickable search results across your whole site.

What's Next

Start with one template, not one random page. Add clean Article or BreadcrumbList markup, validate it, deploy it, and then inspect the rendered HTML. Structured data is boring when it works, which is exactly what you want.