Schema markup is one of the highest-leverage, lowest-effort things you can do for SEO. It doesn’t change what your visitors see — it changes what search engines understand. Add it correctly and your pages become eligible for rich results (star ratings, FAQs, breadcrumbs, product prices) and give Google a much clearer picture of what each page is about. This guide covers the three practical ways to add it, a step-by-step JSON-LD walkthrough, the types worth prioritising, and how to validate the result.
What schema markup actually is
Schema markup is structured data written in the vocabulary defined at schema.org. The recommended format — and the one Google prefers — is JSON-LD: a small block of JSON you drop into your page. It sits invisibly in the HTML and describes the page’s entities: this is an Organization, that is a Product with this price, this page is an Article published on that date.
The three ways to add schema markup
There is no single “right” method — pick the one that matches how your site is built and how much control you want.
- By hand, with JSON-LD. The most control and the most portable. You write the JSON-LD yourself and paste it into the page. Best when you want exact markup and don’t want a plugin’s output getting in the way.
- With a CMS plugin. On WordPress, plugins like Yoast SEO or Rank Math add baseline Organization, WebSite and Article schema automatically. Fast, but the output is generic and often incomplete for anything beyond the basics.
- With a schema generator. A generator reads your page, detects its type, and writes copy-ready JSON-LD for you — the speed of a plugin with the completeness of hand-authoring. Best when you have many pages or page types to cover.
Step by step: adding JSON-LD by hand
Here is the full process for adding schema to a single page manually.
1. Choose the right type
Match the schema type to the page: Organization and WebSite for the homepage, Article or BlogPosting for posts, Product for product pages, LocalBusiness for a location, FAQPage for genuine Q&A content. Don’t force a type that doesn’t match — markup that misrepresents the page can trigger a manual action.
2. Write the JSON-LD
Build the block for your chosen type. A minimal Organization looks like this:
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "Organization",
"name": "Acme Tools",
"url": "https://acmetools.com/",
"logo": "https://acmetools.com/logo.png"
}
</script>Fill in the properties that genuinely apply to your page. More complete, accurate markup is better than a longer block padded with guesses.
3. Add it to the page’s <head>
Paste the whole <script type="application/ld+json"> block into the page’s <head>. Google also reads JSON-LD from the <body>, so if your CMS only lets you inject into the body, that works too — the key is that the markup is present and valid.
4. Validate before you ship
Never publish schema without testing it. A single misplaced comma invalidates the whole block. Validation takes thirty seconds (see below).
The schema types that matter most
You don’t need dozens of types. For most sites, these carry the weight:
- Organization & WebSite — establish your brand as an entity; add once, sitewide.
- BreadcrumbList — shows a breadcrumb trail in search results and clarifies site structure.
- Article / BlogPosting — for editorial content, with headline, author and publish date.
- Product — price, availability and reviews; can win the coveted product rich result.
- FAQPage — for pages that genuinely answer distinct questions (only add it where the Q&A is visible on the page).
- LocalBusiness — name, address, hours and geo for physical locations.
Tip: Reference shared entities with @id instead of repeating them. Define your Organization once with an @id, then point to it from every page’s Article or Product node. It keeps your markup clean and helps search engines connect the pages to one brand.
How to validate your schema markup
Two free tools catch almost every problem:
- Google Rich Results Test — paste a URL or code snippet; it tells you which rich results the page is eligible for and flags errors and warnings.
- Schema.org Validator — a stricter, vocabulary-level check that catches issues Google’s tool ignores.
Run both. “Eligible for rich results” in the first plus a clean pass in the second means your markup is sound. Note that eligibility is not a guarantee — Google decides when to show a rich result — but valid markup is the non-negotiable requirement.
Common mistakes to avoid
- Marking up content that isn’t on the page. Schema must reflect visible content. FAQ schema with no visible FAQ, or review stars you invented, violates Google’s guidelines.
- Leaving broken JSON. One trailing comma breaks the block silently. Always validate.
- Blanket-adding FAQPage everywhere. It reads as manipulative and no longer earns rich results on most sites. Use it only for genuine Q&A.
- Forgetting to update it. Prices, dates and availability go stale. Markup that contradicts the page hurts more than none at all.
The faster way, at scale
Hand-authoring works for a handful of pages. Across a whole site — dozens of templates, hundreds of URLs — it doesn’t scale, and gaps are inevitable. This is where a generator earns its place: the Daylytix Schema Markup Generator crawls your pages, detects each one’s type, and produces valid, copy-ready JSON-LD — including the entity and breadcrumb markup most sites miss. You get the completeness of hand-authoring without spending an afternoon per page.
Frequently asked questions
What is schema markup?
Schema markup is structured data — usually JSON-LD — that you add to a page to describe its content to search engines. It powers rich results like star ratings, FAQs and breadcrumbs, and helps Google understand what a page is about.
Do I need to code to add schema markup?
Not necessarily. You can hand-write JSON-LD, use a CMS plugin like Yoast or Rank Math, or use a schema generator that writes the markup for you. Only the manual route requires editing your HTML.
Where do I put schema markup on a page?
Inside a <script type="application/ld+json"> block, ideally in the <head>. Google also reads it from the <body>, so either works as long as the markup is valid.
How do I know if my schema markup is working?
Test it in Google’s Rich Results Test and the Schema.org Validator. Both parse your markup, flag errors, and show which rich results the page is eligible for.