Tools Docs Pricing Journal Changelog Unlock
English 中文 日本語 Español
GitHub
← Back to Journal
· 7 min read

Schema Markup for SEO: How to Add Structured Data Without Plugins

Structured data helps search engines understand your content and earn rich snippets. Here's how to implement schema markup from scratch using JSON-LD — no plugins, no paid tools.

Schema markup is the difference between telling search engines “here’s some text” and telling them “this is an article, written by this author, published on this date, about this topic, with these frequently asked questions.” One earns you rich snippets. The other doesn’t.

The good news: you don’t need a WordPress SEO plugin, a paid schema generator, or a developer certification. If you can write HTML, you can add structured data. This guide shows you how.

What Schema Markup Actually Does

Search engines crawl your HTML and try to understand what your page is about. They’re good at reading text, but they can’t always tell the difference between a product price, a recipe ingredient, and a random number that happens to look like a price.

Schema markup — specifically JSON-LD — solves this by adding a machine-readable layer on top of your content. You wrap your data in a standardized format that explicitly says “this is a product name, this is the price, this is the availability.”

The payoff: rich results. Instead of a plain blue link in search results, your page can show star ratings, FAQ accordions, breadcrumb navigation, event dates, and more. Rich results increase click-through rates by 20-30% on average because they take up more space and look more authoritative.

JSON-LD vs Microdata vs RDFa

Three formats exist for structured data. Use JSON-LD. Here’s why:

JSON-LD is a <script type="application/ld+json"> block placed in your page’s <head> or <body>. It keeps your structured data completely separate from your visible HTML. Google recommends it. It’s the easiest to maintain. It’s what every example in this guide uses.

Microdata embeds schema attributes (itemprop, itemscope, itemtype) directly into your HTML tags. It’s messy, couples your markup to your content structure, and Google has deprecated it in favor of JSON-LD.

RDFa is similar to Microdata but even more verbose. Nobody uses it for SEO.

If you’re on a framework like Astro or Next.js, JSON-LD is trivially easy — just add a <script> tag in your layout template. No build step, no plugin, no dependency.

The Five Schema Types Every Indie Site Needs

You don’t need to mark up everything. Focus on the schema types that Google actually rewards with rich results and that apply to most content sites.

1. Article (or BlogPosting)

The most essential schema for any content site. Tells Google “this is a published article with an author, date, and headline.”

{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "How to Do Keyword Research Without Paid Tools",
  "author": {
    "@type": "Person",
    "name": "Jane Doe",
    "url": "https://example.com/about"
  },
  "datePublished": "2026-01-15",
  "dateModified": "2026-01-20",
  "image": "https://example.com/images/article-cover.jpg",
  "publisher": {
    "@type": "Organization",
    "name": "Example Site",
    "logo": {
      "@type": "ImageObject",
      "url": "https://example.com/logo.png"
    }
  },
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "https://example.com/article-url"
  }
}

This alone can get your article into Google News, Top Stories carousels, and “About this result” panels.

2. FAQPage

If your article has a FAQ section, FAQPage schema can earn you an expandable accordion directly in search results — taking up significant vertical space and pushing competitors down.

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "Do I need paid tools for SEO?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "No. Google Search Console, PageSpeed Insights, and free keyword research tools cover most SEO needs for indie sites."
      }
    },
    {
      "@type": "Question",
      "name": "How long does it take to rank?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Most pages take 3-6 months to rank for competitive keywords. Long-tail keywords can rank in weeks."
      }
    }
  ]
}

The key: every question in your FAQ must have a visible answer on the page. Don’t add questions that aren’t in your content — Google checks.

3. BreadcrumbList

Shows navigation breadcrumbs in search results instead of a bare URL. This makes your result look more polished and gives users context about where the page sits in your site structure.

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

4. Organization

Helps Google understand your brand as an entity. This feeds into knowledge panels and “About this result” features.

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

The sameAs array links your organization to its social profiles — this helps with entity recognition across Google’s systems.

5. WebSite (with SearchAction)

If your site has search functionality, adding a SearchAction lets Google display a search box directly in your search result snippet.

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

How to Implement Schema in Astro, Next.js, and Plain HTML

Astro

In your layout or page template, add the script tag directly:

---
const article = {
  headline: "Schema Markup Guide",
  datePublished: "2026-07-23",
  author: "Jane Doe"
};
---
<script type="application/ld+json" set:html={JSON.stringify({
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  headline: article.headline,
  datePublished: article.datePublished,
  author: { "@type": "Person", name: article.author }
})} />

For Astro, use set:html to inject the serialized JSON. Don’t use is:inline — Astro will process and include it correctly.

Next.js

Use the next/script component or a <script> tag in your layout:

import Script from 'next/script'

export function ArticleSchema({ article }) {
  return (
    <Script
      id="article-schema"
      type="application/ld+json"
      dangerouslySetInnerHTML={{
        __html: JSON.stringify({
          "@context": "https://schema.org",
          "@type": "BlogPosting",
          headline: article.title,
          datePublished: article.date,
          author: { "@type": "Person", name: article.author }
        })
      }}
    />
  )
}

Plain HTML

Just add the script tag anywhere in your <head> or <body>:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "Schema Markup Guide",
  "datePublished": "2026-07-23",
  "author": { "@type": "Person", "name": "Jane Doe" }
}
</script>

Combining Multiple Schema Types on One Page

Most pages need more than one schema type. You can include multiple <script type="application/ld+json"> blocks on the same page — Google reads all of them.

Alternatively, use a @graph array to combine everything into one block:

{
  "@context": "https://schema.org",
  "@graph": [
    { "@type": "Organization", "name": "Example Site", "url": "https://example.com" },
    { "@type": "BlogPosting", "headline": "Schema Guide", "author": { "@type": "Person", "name": "Jane Doe" } },
    { "@type": "BreadcrumbList", "itemListElement": [ ... ] }
  ]
}

The @graph approach is cleaner for sites with many schema types per page. It’s a single source of truth you can generate programmatically from your frontmatter or CMS data.

Validating Your Schema (Free)

Never deploy schema without validating it. Invalid markup won’t earn rich results and can trigger warnings in Google Search Console.

Google Rich Results Test — The definitive validator. Paste your URL or raw JSON-LD, and it shows exactly which rich result types your markup qualifies for, plus any errors or warnings.

Schema.org Validator — More lenient than Google’s tool. Useful for checking if your markup is structurally correct even if Google doesn’t support that specific schema type for rich results.

Google Search Console — Check the “Enhancements” section for structured data reports. GSC shows schema errors across your entire site, not just one page.

Validation workflow:

  1. Add schema to your page
  2. Deploy to a publicly accessible URL (or use a staging URL)
  3. Run the URL through the Rich Results Test
  4. Fix any errors (red) — warnings (yellow) are optional but recommended
  5. Submit the URL for re-crawling in GSC

Common Schema Mistakes

Don’t mark up invisible content. Every piece of data in your schema must correspond to visible content on the page. If your FAQ schema has 5 questions but your page only shows 3, Google will flag it.

Don’t use generic placeholders. "description": "Article about SEO" adds no value. Write a real description that matches your meta description.

Don’t forget dateModified. If you update articles, update dateModified in the schema. Google uses this to decide whether to re-crawl and re-evaluate the content.

Don’t nest Organization inside Article incorrectly. Use @graph or separate script tags. Trying to put everything in one nested object leads to invalid markup.

Don’t skip the image field. Articles without an image in schema rarely earn rich results. Use a high-quality image at least 1200×675 pixels.

Measuring Schema Impact

After deploying schema, track its impact:

Google Search Console → Performance → Search Appearance. Filter by “Rich results” to see impressions, clicks, and CTR specifically for pages earning enhanced snippets. Compare before and after.

GSC → Enhancements. Each schema type (Article, FAQ, Breadcrumb) has its own report showing valid pages, warnings, and errors across your entire site.

Expect a 2-4 week delay between deploying schema and seeing rich results in search. Google needs to re-crawl, process the markup, and update its index.

Schema and AI Search (GEO)

Structured data matters beyond Google search results. AI engines — ChatGPT, Perplexity, Claude — increasingly parse schema to understand page content. When an AI system encounters @type: "BlogPosting" with a clear author and date, it has higher confidence in the content’s credibility than a page with unstructured text.

If you’re optimizing for AI search visibility, schema markup is one of the highest-leverage technical changes you can make. It’s not just about rich snippets — it’s about making your content machine-readable for the next generation of search.

Quick Start Checklist

  • Add Organization schema to your homepage (one-time setup)
  • Add WebSite schema with SearchAction to your homepage (one-time setup)
  • Add BlogPosting/Article schema to your article layout template (one-time setup)
  • Add BreadcrumbList schema to your page templates (one-time setup)
  • Add FAQPage schema to articles that have FAQ sections (per article)
  • Validate every page with the Rich Results Test before deploying
  • Monitor GSC Enhancements reports for schema errors
  • Update dateModified when you revise content

The entire setup takes about 2 hours for a typical content site. Once your templates include schema, every new article automatically gets structured data without any extra work. That’s the compounding return — one-time effort, perpetual rich snippet eligibility.

For a complete technical SEO foundation, pair schema markup with a technical SEO audit to ensure your site is crawlable and fast, then focus on internal linking and content quality to drive rankings.

Want to run this analysis on your own site?

ZensInk Pro automates this pipeline. One command, from seed keywords to content plan.

Get Pro →