title:: Implementing JSON-LD Schema Markup: A Developer's Guide to 15 Schema Types description:: A developer's guide to implementing JSON-LD structured data. Covers 15 schema types with code examples, validation, and deployment strategies. focus_keyword:: structured data implementation category:: developers author:: Victor Valentine Romo date:: 2026.02.07
Implementing JSON-LD Schema Markup: A Developer's Guide to 15 Schema Types
Structured data implementation using JSON-LD tells search engines what your content means, not just what it says. When Google encounters a page with valid schema markup, it can generate rich results — star ratings, FAQ accordions, product pricing, event dates — that occupy more SERP real estate and attract higher click-through rates than standard blue links.
JSON-LD is the recommended format because it decouples structured data from HTML markup. You inject a block anywhere in the page, and search engines parse it independently of the visual content. No class attributes, no microdata syntax threaded through your templates.
JSON-LD Fundamentals
Structure and Syntax
Every JSON-LD block starts with @context declaring the vocabulary and @type declaring the entity type:
{
"@context": "https://schema.org",
"@type": "Article",
"headline": "Implementing JSON-LD Schema Markup",
"author": {
"@type": "Person",
"name": "Victor Valentine Romo"
}
}
Nest related entities using typed objects. Reference entities across blocks using @id:
{
"@context": "https://schema.org",
"@type": "Organization",
"@id": "https://example.com/#org",
"name": "Example Corp"
}
Other blocks reference this entity with "publisher": {"@id": "https://example.com/#org"}.
Where to Place JSON-LD
Insert JSON-LD in the or at the end of . Both positions are valid. Google parses the entire HTML document for JSON-LD blocks regardless of position.
For server-rendered applications, inject JSON-LD during server-side rendering to ensure crawlers receive it in the initial HTML response. For JavaScript SPAs, dynamic injection works if the rendering service processes it, but server-side injection is more reliable.
Validation Before Deployment
Validate every schema implementation before deploying to production:
- Google's Rich Results Test — tests whether your markup qualifies for specific rich result types
- Schema.org Validator — validates syntax against the full Schema.org vocabulary
- Google Search Console Enhancements report — monitors structured data errors across your entire site post-deployment
The 15 Schema Types Worth Implementing
1. Article
Applicable to: blog posts, news articles, how-to guides, opinion pieces.
{
"@context": "https://schema.org",
"@type": "Article",
"headline": "Your Article Title",
"description": "Article summary under 160 characters.",
"image": "https://example.com/image.jpg",
"datePublished": "2026-02-07",
"dateModified": "2026-02-07",
"author": {
"@type": "Person",
"name": "Author Name",
"url": "https://example.com/about"
},
"publisher": {
"@type": "Organization",
"name": "Publisher Name",
"logo": {
"@type": "ImageObject",
"url": "https://example.com/logo.png"
}
}
}
Rich result: Enhanced article appearance in search, potential inclusion in Google News and Top Stories.
2. FAQPage
Applicable to: any page with question-and-answer content.
{
"@context": "https://schema.org",
"@type": "FAQPage",
"mainEntity": [
{
"@type": "Question",
"name": "What is structured data?",
"acceptedAnswer": {
"@type": "Answer",
"text": "Structured data is code that helps search engines understand page content."
}
}
]
}
Rich result: FAQ accordion directly in search results, significantly expanding your SERP footprint.
3. HowTo
Applicable to: tutorial pages, step-by-step guides, recipe-style content.
{
"@context": "https://schema.org",
"@type": "HowTo",
"name": "How to Implement JSON-LD",
"step": [
{
"@type": "HowToStep",
"name": "Choose Schema Type",
"text": "Select the schema type that matches your content."
},
{
"@type": "HowToStep",
"name": "Write JSON-LD Block",
"text": "Create the JSON-LD following schema.org specifications."
}
]
}
Rich result: Numbered step display in search results.
4. Product
Applicable to: e-commerce product pages, SaaS pricing pages.
{
"@context": "https://schema.org",
"@type": "Product",
"name": "Product Name",
"description": "Product description.",
"image": "https://example.com/product.jpg",
"brand": {"@type": "Brand", "name": "Brand Name"},
"offers": {
"@type": "Offer",
"price": "49.99",
"priceCurrency": "USD",
"availability": "https://schema.org/InStock",
"url": "https://example.com/product"
},
"aggregateRating": {
"@type": "AggregateRating",
"ratingValue": "4.5",
"reviewCount": "127"
}
}
Rich result: Price, availability, and star rating displayed in search.
5. LocalBusiness
Applicable to: business location pages, contact pages for physical businesses.
{
"@context": "https://schema.org",
"@type": "LocalBusiness",
"name": "Business Name",
"address": {
"@type": "PostalAddress",
"streetAddress": "123 Main St",
"addressLocality": "City",
"addressRegion": "ST",
"postalCode": "12345"
},
"telephone": "+1-555-555-5555",
"openingHoursSpecification": {
"@type": "OpeningHoursSpecification",
"dayOfWeek": ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"],
"opens": "09:00",
"closes": "17:00"
}
}
Rich result: Business information panel, map integration.
6. Organization
Applicable to: homepage, about page.
Establishes entity identity for Google's Knowledge Graph. Include sameAs links to official social profiles and authoritative references.
{
"@context": "https://schema.org",
"@type": "Organization",
"name": "Organization Name",
"url": "https://example.com",
"logo": "https://example.com/logo.png",
"sameAs": [
"https://linkedin.com/company/example",
"https://twitter.com/example"
]
}
7. BreadcrumbList
Applicable to: every page with navigational hierarchy.
{
"@context": "https://schema.org",
"@type": "BreadcrumbList",
"itemListElement": [
{"@type": "ListItem", "position": 1, "name": "Home", "item": "https://example.com"},
{"@type": "ListItem", "position": 2, "name": "Category", "item": "https://example.com/category"},
{"@type": "ListItem", "position": 3, "name": "Page Title"}
]
}
Rich result: Breadcrumb trail replaces URL in search results.
8. Event
Applicable to: event listing pages, conference pages, webinar registration.
Include startDate, endDate, location (physical or virtual), and offers for ticketing. Rich result: event card with date, location, and ticket price.
9. VideoObject
Applicable to: pages with embedded video content.
Include name, description, thumbnailUrl, uploadDate, duration, and contentUrl or embedUrl. Rich result: video thumbnail in search results, potential Video carousel inclusion.
10. Review / AggregateRating
Applicable to: product reviews, service reviews, comparison pages.
Standalone Review schema works for individual reviews. AggregateRating summarizes multiple reviews. Combine with Product, LocalBusiness, or Organization schema for context.
11. SoftwareApplication
Applicable to: SaaS product pages, app landing pages.
Include applicationCategory, operatingSystem, offers, and aggregateRating. Rich result: app information with rating and pricing in search.
12. Course
Applicable to: educational content, training programs, certification pages.
Include provider, description, coursePrerequisites, and hasCourseInstance with scheduling details. Rich result: course listing with provider and description.
13. JobPosting
Applicable to: career pages, job listing pages.
Required properties: title, description, datePosted, hiringOrganization, jobLocation. Rich result: job listing card in Google Jobs.
14. WebSite (with SearchAction)
Applicable to: homepage only.
{
"@context": "https://schema.org",
"@type": "WebSite",
"name": "Site Name",
"url": "https://example.com",
"potentialAction": {
"@type": "SearchAction",
"target": "https://example.com/search?q={search_term_string}",
"query-input": "required name=search_term_string"
}
}
Rich result: Sitelinks search box in branded search results.
15. Speakable
Applicable to: news articles, informational content suitable for voice assistants.
Marks sections of content eligible for text-to-speech by voice assistants. Use CSS selectors or XPath to identify speakable sections.
Implementation Architecture
Template-Level Injection
Build schema generation into your page templates rather than manually adding JSON-LD to individual pages. Create functions that accept page data and return formatted JSON-LD:
function buildArticleSchema(article) {
return {
"@context": "https://schema.org",
"@type": "Article",
"headline": article.title,
"datePublished": article.date,
"author": {"@type": "Person", "name": article.author}
};
}
This approach scales to thousands of pages and ensures consistency.
Multiple Schema Blocks Per Page
A single page can contain multiple JSON-LD blocks. A product page might include Product, BreadcrumbList, and Organization schema. Each block is a separate element.
Handling Dynamic Content
For pages with user-generated reviews, variable pricing, or changing availability, generate JSON-LD server-side using current data. Do not hard-code values that change. Connect the schema generation to the same data source that populates the visible content.
Testing and Deployment Pipeline
Pre-Deployment Validation
Build a three-stage validation pipeline for structured data:
Stage 1: Schema syntax validation. Before the code reaches staging, validate JSON-LD syntax using a linter. Malformed JSON (missing commas, unclosed brackets, incorrect nesting) should fail the build. A simple JSON schema validator in your CI/CD pipeline catches syntax errors automatically.// Example: Validate JSON-LD in build step
const schema = require('./article-schema.json');
try {
JSON.parse(JSON.stringify(schema));
console.log('Schema syntax valid');
} catch (e) {
console.error('Schema syntax error:', e.message);
process.exit(1);
}
Stage 2: Rich Results eligibility. On staging, run the Google Rich Results Test API against rendered pages. This validates not just syntax but whether the markup qualifies for rich result display. Automate this by hitting the Rich Results Test API endpoint in your CI/CD pipeline for key URL templates.
Stage 3: Production monitoring. After deployment, monitor Google Search Console Enhancements report for new errors. Set alerts for error count increases. Structural data errors often appear 3-7 days after deployment as Googlebot crawls the updated pages.
Version Control for Schema Templates
Treat schema generation functions as first-class code. They should live in version-controlled repositories, have code review requirements, and include test coverage. A schema change that introduces an error can affect thousands of pages simultaneously — the blast radius is large.
For template-based sites, build schema generators that accept structured input and produce validated output:
function generateProductSchema(product) {
const schema = {
"@context": "https://schema.org",
"@type": "Product",
"name": product.name,
"description": product.description,
"image": product.imageUrl,
"brand": { "@type": "Brand", "name": product.brand },
"offers": {
"@type": "Offer",
"price": product.price.toString(),
"priceCurrency": product.currency,
"availability": product.inStock
? "https://schema.org/InStock"
: "https://schema.org/OutOfStock"
}
};
if (product.rating) { schema.aggregateRating = { "@type": "AggregateRating", "ratingValue": product.rating.average.toString(), "reviewCount": product.rating.count.toString() }; }
return schema; }
Managing Schema Across Multiple Page Templates
Large sites have dozens of page templates, each requiring different schema types. Build a schema registry — a central mapping of page template to schema type(s) — and enforce that every template has corresponding schema generation logic.
The registry also serves as documentation: new developers can quickly understand which pages have structured data, what types are used, and where the generation logic lives.
| Template | Primary Schema | Secondary Schema |
|---|---|---|
| Homepage | WebSite + Organization | FAQPage (if applicable) |
| Product page | Product | BreadcrumbList |
| Blog post | Article | FAQPage + BreadcrumbList |
| Category page | CollectionPage | BreadcrumbList |
| Contact page | LocalBusiness | BreadcrumbList |
Schema for Entity SEO
Building Entity Identity
Google's Knowledge Graph connects entities — organizations, people, products, concepts — through structured data relationships. Implementing consistent entity markup across your site strengthens Google's understanding of what your organization is, what it does, and how it relates to other entities.The foundation: Organization schema on your homepage with sameAs links to all official profiles and authoritative references. This establishes your canonical entity identity.
Add Person schema for key team members, particularly authors of content. Link Person entities to their published articles using the author property. This connects your content to specific named authors — a signal that Google's E-E-A-T evaluation considers.
Cross-Page Entity Consistency
Use @id references to maintain consistent entity identities across pages. Your organization entity should have the same @id on every page where it's referenced:
{
"@type": "Organization",
"@id": "https://example.com/#organization",
"name": "Your Company"
}
On article pages, reference this entity rather than recreating it:
{
"@type": "Article",
"publisher": { "@id": "https://example.com/#organization" }
}
This tells Google that the same organization published all articles, strengthening the entity connection.
Common Implementation Errors
Error 1: Schema-Content Mismatch
The structured data says the product costs $49.99 but the visible page shows $59.99. Google penalizes this mismatch by ignoring the structured data and potentially flagging a manual action. Always generate schema from the same data source as visible content.
Error 2: Missing Required Properties
Each schema type has required and recommended properties. Missing required properties causes validation failure. Check Google's structured data documentation for each type's requirements before implementation.
Error 3: Self-Referencing Review Schema
Marking up reviews that your own organization wrote about your own products violates Google's structured data guidelines. Review schema should represent genuine third-party reviews or user-generated reviews.
Error 4: Schema on Non-Qualifying Pages
FAQ schema on a page without visible FAQ content. Product schema on a category page that lists multiple products. HowTo schema on a page without step-by-step instructions. The markup must describe content that actually exists on the page.
Error 5: Stale Schema Data
Structured data that references outdated prices, discontinued products, or expired events is worse than no structured data at all. Rich results displaying a $49 price when the actual price is $79 creates a deceptive user experience that Google penalizes. Ensure schema generation connects to live data sources — the same database that updates the visible content should update the structured data simultaneously.
Error 6: Duplicate Schema Across Pages
Identical Organization or WebSite schema repeated verbatim on every page of the site doesn't cause penalties but wastes crawl processing. Use @id references on interior pages to point to the schema entity defined on the homepage rather than re-declaring the full entity on every page. This reduces page weight and signals a coherent entity structure.
Frequently Asked Questions
Does structured data directly improve rankings?
Structured data does not directly boost rankings. It enables rich results — enhanced search result appearances that improve click-through rate. Higher CTR can indirectly influence rankings through engagement signals. The primary benefit is SERP visibility, not ranking position.
How long before rich results appear after implementation?
After deploying valid structured data, allow 2-4 weeks for Google to recrawl and process the markup. Use Google Search Console's URL Inspection tool to request recrawling of critical pages. Rich results are not guaranteed even with valid markup — Google decides whether to display them based on quality signals and SERP context.
Should I use JSON-LD or Microdata?
JSON-LD for nearly all implementations. It's decoupled from HTML structure, easier to maintain, less prone to breaking during template changes, and explicitly recommended by Google. Microdata is valid but creates tight coupling between markup and styling that increases maintenance complexity.
Can structured data trigger a manual penalty?
Yes, if the markup violates Google's guidelines — particularly schema-content mismatch (marking up content that doesn't exist on the page), fake reviews, or spammy markup intended to manipulate rich results. Follow the guidelines precisely and validate before deployment.
How do I monitor structured data health at scale?
Google Search Console Enhancements report surfaces schema errors by type across your entire site. Set up a monthly review cadence. For proactive monitoring, run Screaming Frog crawls with structured data extraction enabled, comparing expected schema types against what's actually deployed on each URL template.What's the ROI of implementing structured data?
The direct ROI is increased click-through rate from rich results. Pages with rich results (star ratings, FAQ accordions, pricing, event dates) typically see 15-30% higher CTR than standard blue links. For a page generating 10,000 impressions per month, a CTR improvement from 3% to 4.5% means 150 additional clicks per month — at zero additional cost. Multiply across dozens or hundreds of pages with structured data and the aggregate traffic impact is substantial. The implementation cost is primarily engineering time — 2-4 hours per page template for initial implementation, plus ongoing validation monitoring.
Do I need to implement every schema type relevant to my site?
Prioritize by rich result impact. Product, FAQ, HowTo, and Review schema produce the most visually prominent rich results. BreadcrumbList and Organization schema provide structural benefits with less visual impact. Speakable and some niche types have limited adoption and impact. Start with the types that produce visible rich results for your highest-traffic page templates, then expand to structural types as resources allow. A phased rollout also makes it easier to measure the CTR impact of each schema type independently.