Schema markup is code you add to your pages that tells search engines exactly what your content represents. A product page isn’t just text and images to Google; with the right structured data, it’s a product with a price, availability status, rating, and review count. That explicit labeling is what triggers rich results in search, feeds the Knowledge Graph, and increasingly shapes how AI systems understand and cite your content.
At Gorilla Marketing, we implement and audit structured data as part of our technical SEO work. Schema isn’t glamorous, but it’s one of the clearest lines you can draw between a technical change and a visible SERP improvement. This guide covers what structured data is, which formats to use, which schema types matter most by page type, how to test your implementation, and how to measure whether it’s actually working.
What Is Structured Data?
Structured data is a standardized format for providing information about a page and classifying its content. When you mark up a recipe page with structured data, you’re telling search engines: “This page contains a recipe. The cook time is 30 minutes. The rating is 4.7 out of 5.” Without that markup, a search engine has to infer all of that from unstructured HTML, and inference is unreliable.
The vocabulary behind most structured data on the web is Schema.org, a collaborative project launched in 2011 by Google, Bing, Yahoo, and Yandex. Schema.org defines hundreds of entity types (called “types”) and properties. You pick the type that matches your content, fill in the relevant properties, and embed the markup in your page’s code.
Structured data doesn’t guarantee a ranking boost. Google has been clear about that. What it does guarantee is eligibility. Without Product markup, your product page can’t show star ratings and pricing in search results. Without FAQ markup, your questions won’t expand in the SERP. Without Event markup, your event won’t appear in Google’s event listings. Eligibility is the prerequisite, and structured data is how you earn it.
What’s the Difference Between Schema Markup and Structured Data?
These terms get used interchangeably, but there’s a technical distinction worth knowing. Structured data is the broader concept: any organized data format that search engines can read. Schema markup specifically refers to structured data that uses the Schema.org vocabulary.
All schema markup is structured data. Not all structured data is schema markup. Open Graph tags (used by Facebook and other social platforms) are structured data, but they don’t use Schema.org types. Twitter Cards are structured data too. In practice, when SEOs say “structured data,” they almost always mean Schema.org markup. That’s what Google’s documentation covers, what rich results require, and what we’ll focus on here.
JSON-LD, Microdata, or RDFa: Which Format Should You Use?

Schema.org markup can be implemented in three formats. Each one delivers the same information to search engines; they differ in how and where the code lives on the page.
JSON-LD
JSON-LD (JavaScript Object Notation for Linked Data) is Google’s recommended format. The markup sits in a tag in the page's or , completely separate from the visible HTML. This separation is its biggest advantage: you can add, edit, or remove structured data without touching the page's content or layout.
A basic JSON-LD example for an organization:
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "Organization",
"name": "Example Company",
"url": "https://www.example.com",
"logo": "https://www.example.com/logo.png",
"sameAs": [
"https://www.linkedin.com/company/example",
"https://twitter.com/example"
]
}
</script>
JSON-LD is the format most developers prefer because it's clean, easy to template, and doesn't create dependencies between your markup and your front-end code. If you're choosing a format for a new implementation, this is the one.
Microdata
Microdata embeds structured data directly into HTML elements using attributes like itemscope, itemtype, and itemprop. The markup is woven into the page's visible content, which means any change to the HTML structure can break it. Microdata was more common before JSON-LD gained traction and still appears on older sites, but it's harder to maintain and more error-prone.
RDFa
RDFa (Resource Description Framework in Attributes) works similarly to Microdata, embedding structured data into HTML using attributes like typeof, property, and vocab. It's more flexible than Microdata and supports multiple vocabularies, but that flexibility comes with complexity. Unless you're working on a site that already uses RDFa extensively, there's little reason to choose it over JSON-LD.
The short answer: use JSON-LD. Google recommends it, it's the easiest to implement and maintain, and it's what virtually all modern schema tools and plugins generate.
Which Schema Types Matter Most?
Schema.org lists hundreds of types, but a relatively small subset drives the rich results and entity signals that actually affect your search visibility. Here's what to prioritize, organized by page type.
Organization and LocalBusiness
Every site should have Organization markup on the homepage at minimum. It establishes your brand entity, links to your social profiles, and connects your site to the Knowledge Graph. If you operate from a physical location, LocalBusiness (or a more specific subtype like Restaurant, Dentist, or LegalService) adds address, opening hours, phone number, and geographic coordinates.
For businesses with multiple locations, each location page should carry its own LocalBusiness markup with location-specific details. This connects directly to local SEO performance, reinforcing the relationship between your site, your Google Business Profile, and the physical locations you serve.
Product
Product markup is non-negotiable for e-commerce SEO. It enables rich results that display price, availability, review ratings, and shipping information directly in search. These enhanced listings consistently outperform plain blue links in click-through rate.
A solid Product implementation includes: name, description, image, SKU, brand, price, currency, availability, and aggregate ratings if you collect reviews. The more properties you populate accurately, the richer the result Google can display.
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "Product",
"name": "Wireless Noise-Canceling Headphones",
"image": "https://www.example.com/headphones.jpg",
"brand": {
"@type": "Brand",
"name": "Example Audio"
},
"sku": "WNC-400",
"offers": {
"@type": "Offer",
"price": "249.99",
"priceCurrency": "USD",
"availability": "https://schema.org/InStock",
"url": "https://www.example.com/headphones"
},
"aggregateRating": {
"@type": "AggregateRating",
"ratingValue": "4.6",
"reviewCount": "312"
}
}
</script>
Article and BlogPosting
Article markup helps Google understand your editorial content: who wrote it, when it was published, when it was last updated, and what organization published it. For news sites, it's essential for Google News eligibility. For blog content, it provides authorship signals and can trigger article-style rich results with images and publication dates.
The key properties: headline, author (linked to a Person entity), datePublished, dateModified, publisher (linked to an Organization entity), and image. This is straightforward to template across a blog or SEO content section using your CMS.
BreadcrumbList
BreadcrumbList markup generates the breadcrumb trail that appears above your title in search results (e.g., "example.com > Category > Subcategory > Page"). It's one of the simplest schema types to implement and one of the most consistently displayed. Breadcrumbs in search results improve click-through rates by giving searchers context about where a page sits within your site.
FAQ
FAQ markup generates expandable question-and-answer pairs directly in search results. Google has tightened eligibility over time; as of 2023, FAQ rich results only appear for well-known, authoritative government and health websites for most queries. For other sites, the markup is still valid and processed by Google, but rich result display is no longer guaranteed. Implement it where genuine FAQs exist on the page, but don't build a content strategy around FAQ rich results appearing.
Event
Event markup enables event-specific rich results with dates, locations, ticket links, and pricing. If your site lists events (conferences, webinars, performances, classes), this markup directly affects your visibility in Google's event search experience.
VideoObject
If you embed videos on your pages, VideoObject markup enables video rich results with thumbnails, duration, and upload dates. Video results take up significant SERP space, and marked-up videos are eligible for Google's video carousel.
HowTo
HowTo markup structures step-by-step content for rich results that display each step directly in search. Like FAQ, Google has reduced how often it displays HowTo rich results, but the markup still helps search engines understand procedural content. If you have genuinely instructional content with clear steps, it's worth implementing.
Review
Review markup (and AggregateRating) enables star ratings in search results. This applies to Product, LocalBusiness, Recipe, and several other types. The rules are strict: reviews must be about a specific item, not about the site or organization in general. Self-serving reviews (reviewing your own business on your own site) violate Google's guidelines and can result in a manual action.
How Does Schema Markup Affect SEO?
Schema markup doesn't directly change your ranking position. Google has stated this clearly and repeatedly. What it does is improve how your pages appear in search results, which affects click-through rates, and it helps search engines understand your content more accurately, which can indirectly support rankings.
Rich results and click-through rate
The most measurable impact of schema markup is rich results. Pages with star ratings, prices, FAQ expandables, breadcrumbs, or event details take up more visual space in the SERP and attract more clicks than plain listings. The CTR difference varies by industry and result type, but it's consistently positive. More visual real estate in a crowded SERP means more clicks for you and fewer for competitors.
Entity recognition and the Knowledge Graph
When you consistently mark up your organization, people, products, and locations with structured data, you're helping Google build a clearer entity model of your business. That model feeds the Knowledge Graph, which in turn influences Knowledge Panels, brand-related queries, and how Google connects your site to broader topics.
Entity recognition matters more now than it did five years ago. Google's systems increasingly rely on understanding entities and their relationships rather than just matching keywords.
Structured data and E-E-A-T
Structured data supports E-E-A-T signals by making authorship, organizational credentials, and content provenance machine-readable. Article markup with author details, Organization markup with founding dates and social profiles, and Review markup with verified purchases all contribute to the trust picture Google builds about your site. E-E-A-T is its own deep topic; if you want the full picture, we've published a dedicated article covering what Google looks for and why it matters.
Schema and AI search systems
This is where structured data is heading. AI Overviews, ChatGPT with browsing, Perplexity, and other AI-powered search systems all need to understand what a page represents, who published it, and how authoritative the source is. Schema markup provides those signals in a machine-readable format that's far easier for any system (traditional or AI) to parse than unstructured HTML.
Pages with clear structured data are easier for AI systems to cite accurately. If your Organization markup identifies your brand, your Article markup names the author, and your content is semantically clean, you're giving these systems everything they need to reference you correctly. That's not a theoretical advantage; it's already affecting which sources appear in AI-generated answers.
How Do You Decide Which Schema to Implement?
Not every Schema.org type is worth your time. The right approach is to map schema types to your page types based on two criteria: rich result eligibility and entity value.
| Page Type | Primary Schema | Secondary Schema | Rich Result Eligible? |
|---|---|---|---|
| Homepage | Organization | SiteNavigationElement | Knowledge Panel |
| Product pages | Product, AggregateRating | BreadcrumbList, Review | Yes – price, rating, availability |
| Blog posts | Article or BlogPosting | BreadcrumbList, Person (author) | Yes – article appearance |
| Service pages | Service, Organization | BreadcrumbList, FAQ | Limited |
| Location pages | LocalBusiness | PostalAddress, GeoCoordinates | Yes – local pack, map results |
| Event pages | Event | Organization, Offer | Yes – event listings |
| Video content | VideoObject | BreadcrumbList | Yes – video carousel |
| How-to guides | HowTo | Article, BreadcrumbList | Limited (reduced display) |
Start with the types that are eligible for rich results on your highest-traffic pages. For most sites, that means Organization on the homepage, Product on product pages, Article on editorial content, and BreadcrumbList sitewide. Then layer in additional types based on what content you actually have.
How Do You Implement Schema Markup?
Implementation method depends on your technical setup and how many pages need markup.
Manual JSON-LD
For smaller sites or custom implementations, writing JSON-LD directly into page templates is the most controlled approach. You write the markup once per template, populate it with dynamic values from your CMS, and it applies to every page using that template. This requires developer involvement but gives you full control over what's being output.
WordPress plugins
If you're running WordPress, plugins like Yoast SEO, Rank Math, and Schema Pro can generate structured data automatically. These handle the basics well: Organization, Article, BreadcrumbList, and basic Product markup. They fall short on complex or nested schema. If you need custom schema types or deeply connected entity graphs, you'll likely need to supplement plugin output with manual JSON-LD.
Google Tag Manager
GTM can inject JSON-LD into pages without touching your site's codebase. This is useful for marketing teams that don't have ready access to developer resources. The limitation: GTM-injected schema depends on JavaScript execution. Google has confirmed it can process JavaScript-rendered structured data, but it adds a layer of dependency. For critical schema (Product, LocalBusiness), having it in the static HTML is more reliable.
CMS-level templates
For large sites (e-commerce platforms, publishers), the most scalable approach is building schema directly into CMS templates. Your product template automatically generates Product markup from the product database. Your article template pulls author, date, and publisher information. This scales to thousands of pages without manual intervention.
What Are Common Schema Markup Mistakes?
Structured data errors are common, and some are invisible until you check. Here are the mistakes we see most frequently during technical audits.
Markup that doesn't match visible content
Google's guidelines are explicit: structured data must represent content that's visible on the page. If your Product markup claims a 4.8 star rating but the page doesn't display any reviews, that's a violation. If your FAQ markup contains questions that don't appear anywhere on the page, Google can issue a manual action. The rule is simple: if it's in the markup, it must be on the page.
Missing required properties
Each schema type has required and recommended properties. Google's Rich Results Test will flag missing required properties, but missing recommended ones can prevent your page from being eligible for rich results even if the markup is technically valid. For Product markup, leaving out image, offers, or aggregateRating means you've done the work of implementing schema without getting the benefit.
Incorrect nesting
Schema types often contain nested types. A Product contains an Offer, which contains a price and currency. An Article contains an author (Person) and publisher (Organization). When nesting is wrong (putting the Offer outside the Product, or missing the @type on a nested entity), the markup breaks silently. It passes basic validation but doesn't trigger rich results.
Stale or inaccurate data
Schema markup that was accurate at launch can become wrong as your site changes. Product prices change, events end, business hours shift, authors leave the company. If your structured data isn't dynamically populated from your database or CMS, it will drift from reality. Google's systems cross-check markup against page content, and inconsistencies erode trust in your structured data over time.
Overusing schema types with limited support
Implementing schema types that Google doesn't use for rich results wastes effort. Types like SpeakableSpecification, Dataset, and MedicalEntity exist in Schema.org but have limited or no rich result support. Prioritize types that Google actively processes and rewards.
How Do You Test and Validate Schema Markup?
Testing should happen at three stages: during development, after deployment, and on an ongoing basis.
Google's Rich Results Test
The primary validation tool. Paste a URL or code snippet, and it shows you which rich results your page is eligible for, which required properties are present, and which are missing. It also flags errors and warnings. Run every page template through this tool before going live.
Schema Markup Validator (schema.org)
This tool validates your markup against the full Schema.org specification, not just Google's subset. It catches structural errors that the Rich Results Test might not flag. Use it alongside Google's tool for thorough validation.
Google Search Console
The Enhancements section in Search Console shows structured data status across your entire site. It reports valid items, items with warnings, and errors, grouped by schema type. This is your ongoing monitoring tool. Check it regularly, because a template change or CMS update can break structured data across thousands of pages simultaneously.
Structured data in Search Console performance reports
This is where you measure impact. Filter your Search Console performance data by search appearance to see impressions and clicks specifically for pages with rich results. Compare CTR for pages with and without rich results to quantify what your structured data implementation is actually delivering.
How Do You Audit Existing Schema Markup?
If structured data already exists on your site, an audit tells you whether it's working correctly, where gaps exist, and what opportunities you're missing.
Step 1: Crawl and extract
Use a crawler (Screaming Frog, Sitebulb, or similar) to extract all structured data across your site. This gives you a complete picture of what schema types exist, which pages have markup, and which don't.
Step 2: Validate at scale
Run extracted markup through validation tools to identify errors, warnings, and missing properties. Group issues by template, because a single template error typically affects hundreds of pages.
Step 3: Map coverage gaps
Compare your schema coverage against your page types. Do all product pages have Product markup? Do all blog posts have Article markup? Do location pages have LocalBusiness? The gap between what should exist and what does exist is your implementation roadmap.
Step 4: Check for accuracy
Cross-reference markup data against actual page content. Are prices current? Are ratings accurate? Are authors still with the company? Are business hours up to date? Stale data isn't just unhelpful; it can trigger manual actions.
Step 5: Monitor Search Console enhancements
Review Search Console's enhancement reports for each schema type. Track error trends over time. A spike in errors often correlates with a recent site change that broke a template's structured data output.
How Does Schema Markup Connect to Core Web Vitals?
Schema markup itself has virtually zero impact on page load performance. JSON-LD scripts are small (typically under 2KB) and don't render visually, so they don't affect Largest Contentful Paint, Cumulative Layout Shift, or Interaction to Next Paint. Core Web Vitals and structured data are separate technical SEO disciplines that both contribute to search performance but don't directly interact. We've covered Core Web Vitals in a standalone article if you want the details on those metrics.
How Does Schema Support JavaScript-Heavy Sites?
On sites that render content primarily through JavaScript, structured data implementation needs extra attention. Google can process JavaScript-rendered JSON-LD, but it relies on the rendering step of its indexing pipeline, which is slower and less reliable than parsing static HTML.
For JavaScript-heavy sites, the safest approach is server-side rendering (SSR) of your JSON-LD. If the structured data is present in the initial HTML response (before any JavaScript executes), Google can parse it during the crawl step rather than waiting for rendering. JavaScript SEO is a broader topic with its own set of challenges; we'll have dedicated coverage on that coming soon.
Getting Structured Data Right From the Start
Schema markup sits at the intersection of technical implementation and search strategy. Getting it right isn't about adding as many types as possible. It's about choosing the types that match your content, implementing them accurately, testing them thoroughly, and monitoring them as your site evolves.
The companies that get the most from structured data are the ones that treat it as an ongoing discipline, not a one-time project. Templates change, content updates, new pages launch, Google adjusts its rich result criteria. Your structured data needs to keep pace.
If your site's structured data hasn't been audited recently, or if you're not sure what's actually being output on your pages, that's the place to start. A structured data audit surfaces the errors and gaps that are quietly costing you rich result eligibility and SERP visibility.




