TL;DR
Schema markup labels the entities, facts, and relationships on your pages so search engines can interpret them more reliably. It can make eligible pages available for rich results, but valid code does not guarantee higher rankings, enhanced listings, Knowledge Panel changes, or AI citations.
Start with a small set of accurate, connected entities. Use the eight JSON-LD templates below as starting points, replace every placeholder, and test both Google feature eligibility and general Schema.org validity before publishing.
What Is Schema Markup, in Plain English?

Schema markup is machine-readable information added to a webpage. It labels what the page describes—such as an article, organization, author, product, review, place, offer, or relationship—instead of leaving search systems to infer everything from unstructured text.
Three related terms are often treated as interchangeable:
- Structured data is the broad category of information organized in a predictable, machine-readable format.
- Schema.org supplies a shared vocabulary of types and properties.
- JSON-LD is a format you can use to place that vocabulary on a page.
Here is a deliberately small example:
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "Organization",
"name": "Example Company",
"url": "https://www.example.com/"
}
</script>
This block states that “Example Company” is an organization and that its website is https://www.example.com/. It does not tell Google that the company deserves higher rankings.
If you need a shorter reference before working through the templates, start with this concise schema markup definition.
Schema markup has three practical uses in SEO:
- Making eligible content available for supported search enhancements.
- Connecting entities and their relationships explicitly.
- Reducing ambiguity about what a page describes.
It is not a direct ranking factor or an automatic ranking switch. A technically valid block can exist on a page that never receives a rich result or improves its organic position.
How Schema Markup Works
A JSON-LD block uses a few recurring elements:
@contextidentifies the vocabulary, normallyhttps://schema.org.@typeidentifies the entity, such asArticle,Product, orOrganization.- Properties describe the entity through values such as its name, URL, image, author, price, or publication date.
- Entities are the distinct things being described.
@idgives an entity a stable identifier that other blocks can reference.
An @id often looks like a URL with a fragment:
https://www.example.com/#organization
It does not need to resolve to a separate page. Its purpose is to identify the same organization consistently wherever that entity appears in your markup.
Suppose an article names a writer and publisher in its visible text. Without connected markup, a system must determine whether the author name refers to a person, whether the company is the publisher, and whether that company is the same brand described elsewhere.
Connected structured data can state those relationships directly:
- This entity is an
Article. - This
Personwrote it. - This
Organizationpublished it. - This URL is the article’s primary page.
- The publisher is the entity identified by
https://www.example.com/#organization.
Stable identifiers help you avoid repeatedly describing one organization as though it were several unrelated entities. Reusing one correct @id creates a smaller, more coherent entity graph.
What Schema Markup Can and Cannot Do
Accurate schema markup can:
- Make a page eligible for supported rich results.
- Clarify relationships among articles, authors, brands, products, offers, reviews, and locations.
- Help machines distinguish between similarly named entities.
- Present details such as price, availability, ratings, and breadcrumbs in a structured format.
- Reduce ambiguity created by complex layouts or wording.
Schema markup cannot guarantee:
- Higher rankings.
- A rich result for every eligible page or query.
- Knowledge Panel changes.
- Crawling or indexing.
- Inclusion in AI-generated answers.
- Citations from an AI search system.
- Acceptance of claims that conflict with the visible page.
- Continued eligibility when a search feature changes.
Treat structured data as a precise description, not proof of importance or truth. Search engines still evaluate the page, website, data consistency, policies, query context, and other signals independently.
Which Schema Markup Types Are Worth Using?
Most websites do not need dozens of schema markup types. You need the types that accurately describe your main pages, supported by entities that connect those pages to the relevant organization, author, product, or location.
The eight types in this guide cover common editorial, ecommerce, local, and business needs.
| Schema type | Primary purpose | Potential search use | Important restriction | Main value |
|---|---|---|---|---|
Article | Describe an editorial article and its author or publisher | Article-related presentation where supported | Dates, author, image, and headline must describe the page | Content and entity understanding |
FAQPage | Describe visible questions with publisher-supplied answers | FAQ presentation where currently supported | Every marked-up question and answer must be accessible on the page | Content understanding |
HowTo | Describe an ordered process | Search or machine interpretation where supported | Every marked-up step must exist visibly and in order | Procedural understanding |
Product | Describe a product and its commercial data | Product-related search experiences | Price, availability, currency, variants, and ratings must remain accurate | Commercial presentation |
Organization | Define a brand or legal organization | Organization-related interpretation and presentation | Use authoritative details and one stable identity | Entity understanding |
LocalBusiness | Define a physical or locally operating business | Local and business-related interpretation | Public name, address, phone, hours, and location must agree | Local entity understanding |
BreadcrumbList | Describe a page’s hierarchical path | Breadcrumb presentation | Paths and URLs must reflect the accessible site hierarchy | Navigation and hierarchy |
Review | Describe an attributable review of an item | Review-related presentation for eligible content | Reviews must be genuine, visible, and connected to the correct item | Review understanding |
Passing a validator is only the first gate. A page may also need to satisfy these conditions:
- The JSON must be syntactically valid.
- The vocabulary and nesting must be valid.
- The search engine must support the type for a relevant feature.
- The page and markup must comply with applicable policies.
- Required information must be present.
- Structured facts must agree with visible content.
- The page must be crawlable and indexable.
- The search engine must choose to show the enhancement.
Feature support changes. Check Google’s current structured-data documentation and your Search Console reports before forecasting traffic or click-through improvements.
Types That Can Support Visible Search Features
Product is commercially useful because accurate product and offer data can support product-related search experiences. Eligibility depends on the page, supplied properties, merchant setup, and current search policies.
Eligible Review markup can support review presentation when the reviewed item, page, and data satisfy current requirements. An aggregate rating copied from an unverifiable source is not a safe shortcut to visible stars.
BreadcrumbList can help a search engine interpret and display a page’s position in your site hierarchy. Use sensible positions, accurate names, and canonical absolute URLs.
Article markup clarifies the headline, author, publisher, dates, image, and primary URL. It supports interpretation, but you should not promise a particular visual enhancement.
LocalBusiness data reinforces public business details and relationships. Local visibility still depends on factors beyond structured data, including real-world location information, relevance, website quality, and consistency.
Types With Limited or Changing Search Presentation
FAQPage remains part of the Schema.org vocabulary, but visible search support can be limited or changed by the search engine. Do not present FAQ schema as a reliable way to occupy more results-page space.
Use it when a page contains useful, visible, publisher-written questions and answers that the markup describes accurately.
HowTo is also valid Schema.org vocabulary. It can describe procedural content for machine interpretation, but its value should not depend on assumptions about a particular search presentation.
The distinction matters: a type can be valid at Schema.org without being supported for a current Google rich-result feature.
Types Used Primarily for Entity Understanding
Organization schema defines a brand through its name, canonical URL, logo, official profiles, contact details, and stable identifier. Article, Product, WebSite, and other entities can reference that identifier rather than creating disconnected versions of the company.
This structure may also help other systems disambiguate an organization, author, product, or location. That is an interpretive benefit, not a guaranteed acquisition channel.
AI systems use different data sources, retrieval methods, and trust assessments. Adding schema cannot force an AI platform to quote, cite, recommend, or consume your information.
Eight Copy-Paste Schema Markup Examples

The following examples are complete JSON-LD script blocks without comments or trailing commas. Replace every example value with accurate information from your website, use absolute URLs, and preserve valid JSON syntax.
A schema markup generator can accelerate the first draft. It cannot determine whether you selected the right page type, whether another tool already generates the entity, or whether your claims match the visible page.
Article Schema Markup Example
Use this when: The page is an editorial article, news story, or blog post.
Current role: Describes article identity, authorship, publication, images, and publisher relationships.
Core fields: Headline, image, publication date, author, publisher, and main page URL.
Useful additional fields: Description, modification date, stable author identifier, and stable publisher identifier.
Visible-content rule: The headline, author, dates, and article content must reflect what users see.
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "Article",
"@id": "https://www.example.com/blog/schema-guide/#article",
"headline": "A Practical Guide to Schema Markup",
"description": "Learn how to choose, implement, and test schema markup.",
"image": [
"https://www.example.com/images/schema-guide-1200x800.jpg"
],
"datePublished": "2026-10-15T09:00:00+00:00",
"dateModified": "2026-11-10T14:30:00+00:00",
"mainEntityOfPage": {
"@type": "WebPage",
"@id": "https://www.example.com/blog/schema-guide/"
},
"author": {
"@type": "Person",
"@id": "https://www.example.com/authors/alex-rivera/#person",
"name": "Alex Rivera",
"url": "https://www.example.com/authors/alex-rivera/"
},
"publisher": {
"@type": "Organization",
"@id": "https://www.example.com/#organization",
"name": "Example Company",
"url": "https://www.example.com/",
"logo": {
"@type": "ImageObject",
"url": "https://www.example.com/images/logo.png"
}
}
}
</script>
Use an absolute canonical URL for mainEntityOfPage. The publisher identifier should match the @id used in your Organization markup.
Do not update dateModified automatically on every page load or trivial template change. Use it for meaningful article updates that readers can inspect.
FAQPage Schema Markup Example
Use this when: A page contains publisher-written questions and complete answers intended for users.
Current role: Describes question-and-answer content. Search presentation depends on current feature support and eligibility.
Core fields: A mainEntity array containing Question objects and complete acceptedAnswer values.
Useful additional fields: Page-specific questions that genuinely help readers.
Visible-content rule: Every marked-up question and full answer must appear on the page.
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "FAQPage",
"@id": "https://www.example.com/shipping-faq/#faq",
"mainEntity": [
{
"@type": "Question",
"name": "How long does standard delivery take?",
"acceptedAnswer": {
"@type": "Answer",
"text": "Standard delivery normally takes three to five business days after the order has been dispatched."
}
},
{
"@type": "Question",
"name": "Can I change my delivery address?",
"acceptedAnswer": {
"@type": "Answer",
"text": "You can change the delivery address before dispatch by contacting the support team with your order number."
}
}
]
}
</script>
Do not place answers only in JSON-LD. Answers inside normal expandable sections can still be accessible, but users must be able to reach the complete content.
Avoid generating identical FAQ entities across unrelated pages. Each question should belong on the page where its markup appears.
HowTo Schema Markup Example
Use this when: The page teaches a process through an ordered sequence of steps.
Current role: Describes a visible procedure. Search presentation depends on current platform support.
Core fields: Name and ordered HowToStep entities.
Useful additional fields: Description, image, total time, estimated cost, supplies, tools, step URLs, and step images.
Visible-content rule: Every step must appear on the page in the same order with materially consistent instructions.
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "HowTo",
"@id": "https://www.example.com/guides/install-wall-shelf/#howto",
"name": "How to Install a Wall Shelf",
"description": "Install a simple wall shelf using brackets and standard household tools.",
"image": {
"@type": "ImageObject",
"url": "https://www.example.com/images/install-wall-shelf.jpg"
},
"totalTime": "PT45M",
"estimatedCost": {
"@type": "MonetaryAmount",
"currency": "USD",
"value": "40"
},
"supply": [
{
"@type": "HowToSupply",
"name": "Wall shelf"
},
{
"@type": "HowToSupply",
"name": "Wall plugs and screws"
}
],
"tool": [
{
"@type": "HowToTool",
"name": "Drill"
},
{
"@type": "HowToTool",
"name": "Spirit level"
}
],
"step": [
{
"@type": "HowToStep",
"position": 1,
"name": "Mark the bracket positions",
"text": "Hold the shelf against the wall, use a spirit level, and mark the bracket positions.",
"url": "https://www.example.com/guides/install-wall-shelf/#mark-positions",
"image": "https://www.example.com/images/shelf-step-1.jpg"
},
{
"@type": "HowToStep",
"position": 2,
"name": "Drill the fixing holes",
"text": "Drill holes at the marked positions and insert the correct wall plugs.",
"url": "https://www.example.com/guides/install-wall-shelf/#drill-holes",
"image": "https://www.example.com/images/shelf-step-2.jpg"
},
{
"@type": "HowToStep",
"position": 3,
"name": "Attach and level the shelf",
"text": "Secure the brackets, place the shelf on them, and confirm that it is level.",
"url": "https://www.example.com/guides/install-wall-shelf/#attach-shelf",
"image": "https://www.example.com/images/shelf-step-3.jpg"
}
]
}
</script>
Use ISO 8601 duration syntax for totalTime, such as PT45M for 45 minutes. Do not invent costs, tools, or supplies to make the block appear more complete.
Product Schema Markup Example
Use this when: The page describes one purchasable product or a clearly selected variant.
Current role: Can support product-related search experiences when the page and data meet current requirements.
Core fields: Product name and enough product or offer information for the feature you are targeting.
Useful additional fields: Images, description, SKU, brand, canonical URL, offer, availability, item condition, shipping details, return policy, and verified ratings.
Visible-content rule: Price, currency, availability, condition, rating, review count, and product identity must match the page and current commerce records.
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "Product",
"@id": "https://www.example.com/products/oak-desk-lamp/#product",
"name": "Oak Desk Lamp",
"image": [
"https://www.example.com/images/oak-desk-lamp-front.jpg",
"https://www.example.com/images/oak-desk-lamp-side.jpg"
],
"description": "An adjustable desk lamp with a solid oak base and linen shade.",
"sku": "LAMP-OAK-01",
"brand": {
"@type": "Brand",
"name": "Example Home"
},
"url": "https://www.example.com/products/oak-desk-lamp/",
"offers": {
"@type": "Offer",
"url": "https://www.example.com/products/oak-desk-lamp/",
"priceCurrency": "USD",
"price": "129.00",
"availability": "https://schema.org/InStock",
"itemCondition": "https://schema.org/NewCondition"
},
"aggregateRating": {
"@type": "AggregateRating",
"ratingValue": "4.7",
"reviewCount": "86"
}
}
</script>
Remove the entire aggregateRating block unless the rating is genuine, visible, relevant to that product, and maintained. Do not present a site-wide business rating as a product rating.
For product variants, make sure the selected SKU, price, availability, URL, images, and attributes describe the same variant. Add shipping and return-policy properties only when they reflect your actual policies.
Organization Schema Markup Example
Use this when: You need to define the organization behind a website, brand, or publication.
Current role: Supports entity understanding and consistent brand information.
Core fields: Name, canonical URL, and a stable @id.
Useful additional fields: Logo, authoritative profile links, appropriate contact details, and publicly verifiable organization facts.
Visible-content rule: The details should agree with the site’s branding, contact pages, policies, and official profiles.
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "Organization",
"@id": "https://www.example.com/#organization",
"name": "Example Company",
"url": "https://www.example.com/",
"logo": {
"@type": "ImageObject",
"url": "https://www.example.com/images/example-company-logo.png",
"width": 600,
"height": 200
},
"sameAs": [
"https://www.linkedin.com/company/example-company/",
"https://www.youtube.com/@examplecompany"
],
"contactPoint": {
"@type": "ContactPoint",
"contactType": "customer support",
"telephone": "+1-555-010-2000",
"email": "support@example.com",
"availableLanguage": [
"English"
]
}
}
</script>
Reuse https://www.example.com/#organization when Article, Product, WebSite, or other markup refers to this company. Do not create different identifiers such as #brand, #publisher, and #company unless they represent genuinely different entities.
Only include official profiles and contact channels. sameAs is not a list of every directory, article, or social mention associated with the company.
LocalBusiness Schema Markup Example
Use this when: The page represents a real local business or location with public operational details.
Current role: Supports local entity understanding and may contribute to business-related presentation. It does not guarantee local visibility.
Core fields: Specific business type, name, URL, address, and appropriate location information.
Useful additional fields: Image, telephone, coordinates, opening hours, price range, and a stable location identifier.
Visible-content rule: Name, address, phone number, hours, coordinates, and other claims must agree with visible pages and operational records.
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "Dentist",
"@id": "https://www.exampledental.com/locations/downtown/#business",
"name": "Example Dental Downtown",
"image": "https://www.exampledental.com/images/downtown-clinic.jpg",
"url": "https://www.exampledental.com/locations/downtown/",
"telephone": "+1-555-010-3000",
"priceRange": "$$",
"address": {
"@type": "PostalAddress",
"streetAddress": "100 Market Street",
"addressLocality": "Portland",
"addressRegion": "OR",
"postalCode": "97205",
"addressCountry": "US"
},
"geo": {
"@type": "GeoCoordinates",
"latitude": 45.5205,
"longitude": -122.6789
},
"openingHoursSpecification": [
{
"@type": "OpeningHoursSpecification",
"dayOfWeek": [
"https://schema.org/Monday",
"https://schema.org/Tuesday",
"https://schema.org/Wednesday",
"https://schema.org/Thursday",
"https://schema.org/Friday"
],
"opens": "08:00",
"closes": "17:00"
}
]
}
</script>
Use the most specific accurate subtype, such as Dentist, Restaurant, or AutoRepair, rather than defaulting to LocalBusiness. For a multi-location company, give each real location its own page and stable identifier when appropriate.
Never invent service areas, amenities, opening hours, ratings, or coordinates. When information changes, update the visible page, operational systems, directory profiles, and structured data through one coordinated process.
BreadcrumbList Schema Markup Example
Use this when: A page has a meaningful, user-accessible position in your site hierarchy.
Current role: Can support breadcrumb presentation, subject to the search engine’s processing and display decisions.
Core fields: Ordered ListItem objects with positions, names, and URLs.
Useful additional fields: Canonical absolute URLs for each accessible level in the hierarchy.
Visible-content rule: The path should match the page’s logical hierarchy and not contradict navigation or canonical URLs.
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "BreadcrumbList",
"@id": "https://www.example.com/blog/technical-seo/schema-guide/#breadcrumb",
"itemListElement": [
{
"@type": "ListItem",
"position": 1,
"name": "Home",
"item": "https://www.example.com/"
},
{
"@type": "ListItem",
"position": 2,
"name": "Blog",
"item": "https://www.example.com/blog/"
},
{
"@type": "ListItem",
"position": 3,
"name": "Technical SEO",
"item": "https://www.example.com/blog/technical-seo/"
},
{
"@type": "ListItem",
"position": 4,
"name": "Schema Markup Guide",
"item": "https://www.example.com/blog/technical-seo/schema-guide/"
}
]
}
</script>
Do not invent breadcrumb levels solely to insert keywords. Each intermediate URL should represent a logical, accessible part of the site.
Watch for canonical conflicts. Tracking URLs, redirected taxonomy pages, and noncanonical variants can describe a different hierarchy from the one you want search engines to process.
Review Schema Markup Example
Use this when: A page contains a genuine, attributable review of an identifiable item.
Current role: May support review presentation when the reviewed item, page, and implementation meet current requirements.
Core fields: Reviewed item, reviewer, rating, and sufficient information to describe the visible review.
Useful additional fields: Publication date, complete review text, best and worst rating values, and a stable reviewed-item identifier.
Visible-content rule: The reviewer, item, rating, date, and review text must be visible and verifiable.
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "Review",
"@id": "https://www.example.com/reviews/example-writing-app/#review",
"itemReviewed": {
"@type": "SoftwareApplication",
"@id": "https://www.example.com/software/example-writing-app/#software",
"name": "Example Writing App",
"applicationCategory": "BusinessApplication",
"operatingSystem": "Web"
},
"author": {
"@type": "Person",
"name": "Morgan Lee",
"url": "https://www.example.com/authors/morgan-lee/"
},
"reviewRating": {
"@type": "Rating",
"ratingValue": "4.5",
"bestRating": "5",
"worstRating": "1"
},
"datePublished": "2026-09-20",
"reviewBody": "Example Writing App provides a clear editing workflow and useful collaboration features, although its reporting options are limited."
}
</script>
A single Review represents one reviewer’s assessment. aggregateRating summarizes multiple ratings and requires a visible, maintained rating value and count.
Schema.org may accept markup that a search engine does not use for a specific feature. Check current eligibility requirements before adding review markup, and avoid using selected testimonials to manufacture an unsupported aggregate score.
How to Add Schema Markup Without Creating Duplicates
Before installing a plugin, editing a theme, adding an embed, or deploying custom JSON-LD, inspect the structured data already present on representative live pages. WordPress plugins, Webflow embeds, Shopify themes, review apps, merchant apps, and tag managers can generate markup without an obvious visual indicator.
Common implementation methods include:
- Server-rendered templates: Scalable when developers bind schema directly to authoritative data.
- CMS fields: Useful for editors when fields are validated and mapped consistently.
- Plugins or apps: Fast to deploy but prone to overlap when several tools generate the same entities.
- Custom code: Flexible but requires clear ownership, testing, and maintenance.
- JavaScript injection: Convenient in some systems, but harder to debug when execution is delayed or conditional.
Assign one source of truth for each dynamic field. Product prices should come from commerce data, article authors from the CMS, opening hours from maintained location records, and entity IDs from a documented schema model.
Schema is only one part of technical quality. Use a broader technical SEO priority checklist to address indexing, canonicals, internal links, rendering, and templates alongside structured data.
WordPress Implementation
Start by checking:
- Your primary SEO plugin.
- Dedicated schema plugins.
- Block or page-builder plugins.
- Theme templates.
- Custom fields and post types.
- Header, footer, and tag-manager scripts.
- Ecommerce and review plugins.
SEO plugins may already generate Article, WebPage, Organization, Person, or BreadcrumbList markup. Adding another plugin can create a second publisher, author, breadcrumb trail, or page entity with different identifiers.
For a scalable implementation, connect template fields to reusable entities. An article template can reference one publisher @id, while each author profile uses its own stable Person identifier.
If two systems overlap, disable the redundant module or consolidate the output. Do not delete every repeated type automatically: a Product can legitimately contain an Offer or reference an Organization if those entities connect consistently.
Webflow Implementation
Webflow implementations often use custom code combined with Collection fields. Populate each page’s JSON-LD from the relevant fields instead of copying one static block across every Collection item.
Dynamic values must be serialized correctly. Quotation marks, line breaks, backslashes, and untrusted text can break JSON when inserted without proper handling.
Inspect the published page rather than relying only on Designer previews. Custom-code placement, third-party scripts, publishing settings, and Collection behavior can change the final output.
Do not reuse one article URL, author, publication date, product SKU, or location across an entire Collection. Every generated block must describe its own page.
Shopify Implementation
Shopify themes may include Product, Offer, BreadcrumbList, or Organization data before you install an SEO or review app. Audit the theme, product-review app, merchant integrations, and SEO apps together.
Bind commercial properties to current store data, including:
- Selected variant.
- SKU.
- Price and currency.
- Availability.
- Product URL.
- Product images.
- Review count and rating.
- Shipping and return information where included.
Hard-coded prices and availability become inaccurate when inventory or promotions change. Variant pages are especially vulnerable when the visible selection and structured offer refer to different SKUs.
Retest representative product and collection URLs after theme upgrades or app changes. Generated markup can change even when the storefront looks the same.
How to Check Whether Your Website Already Has Schema Markup
Test the live URL, inspect the rendered page, inventory every detected entity, and compare the values with visible content and source records.
Do not stop after finding the first application/ld+json block. One page may contain separate blocks generated by a theme, plugin, app, template, and tag manager.
View Source can also be incomplete for this purpose. It shows the original server response, while JavaScript-injected markup may appear only in the rendered document after scripts execute.
Use browser developer tools or a rendered-page testing tool to search for:
application/ld+json
Then check for:
- Duplicate
@typevalues describing the same main entity. - Repeated
@idvalues used for different entities. - One entity represented by inconsistent identifiers.
- Conflicting names, URLs, prices, dates, authors, or ratings.
- Multiple canonical URLs.
- Old domains or staging URLs.
- Markup produced only after interaction or consent.
- Data generated by several plugins, themes, apps, or scripts.
Document each producer before making changes. Record the system, template scope, data source, owner, and update trigger for every important block.
A Five-Minute Existing-Schema Check
Use this process:
- Run the live URL through Google’s Rich Results Test.
- Run the URL or rendered code through the Schema.org Validator.
- Open browser developer tools and inspect the rendered HTML.
- Search for every
application/ld+jsonblock. - Inventory each
@typeand@id. - Compare marked-up URLs with the canonical tag.
- Compare names, dates, prices, ratings, and availability with visible content.
- Check whether the CMS or commerce system contains the same values.
The Rich Results Test shows whether Google detects markup relevant to supported enhancements. The Schema.org Validator checks broader vocabulary and structure, including types that may not be used for Google rich results.
Neither tool proves that the data is true. You must compare the machine-readable statements with the page and authoritative records.
How to Identify the Source of Duplicate Markup
Trace duplicates systematically rather than deleting blocks at random. Plugins and apps may generate valid supporting entities even when a page contains several blocks.
Useful clues include:
- Code placement in the document.
- Property ordering and formatting patterns.
- Plugin-specific class names nearby.
- Distinctive logo URLs or default descriptions.
- App domains in image or script URLs.
- Theme files containing matching text.
- Tag-manager containers responsible for injection.
On a staging site, disable one suspected producer at a time and retest the rendered output. You can also change a harmless test value in a controlled field to see which block updates.
Choose one authoritative generator for each entity where possible. When multiple blocks are necessary, connect them with the same stable @id and keep every shared property consistent.
Site crawling can reveal template-level patterns that isolated URL checks miss. If you are deciding which audit tooling you need, this comparison of Screaming Frog and Ahrefs for technical crawling explains how a dedicated crawler can expose implementation issues across a website.
How to Test and Validate Schema Markup
Schema testing requires more than one tool because each test answers a different question.
| Testing method | What it answers | What it cannot prove |
|---|---|---|
| JSON syntax check | Is the JSON parseable? | Whether the vocabulary, facts, or page type are correct |
| Schema.org Validator | Does the markup use general Schema.org vocabulary and structure correctly? | Whether Google supports a rich result for it |
| Google Rich Results Test | Does Google detect markup relevant to supported rich-result features? | Whether Google will display the result |
| Rendered HTML inspection | Is the expected markup present after rendering? | Whether it complies with every search policy |
| Search Console enhancement report | What supported structured-data issues has Google detected on processed URLs? | Complete coverage of every schema type |
| Live search monitoring | Is an enhancement appearing for observed searches? | Permanent display across queries, devices, or users |
Google recommends starting with its Rich Results Test when you want to evaluate supported search enhancements. For general vocabulary validation, use the Schema.org Validator.
Test your code during development and the final production URL after deployment. Production testing catches issues involving rendering, caching, environment variables, consent tools, theme behavior, and dynamic fields.
Where Google provides a relevant enhancement report, monitor it in Search Console. Reports can expose patterns across processed URLs, but they do not replace inspecting representative pages and rendered output.
Complementary crawls can also reveal missing, duplicated, or inconsistent tags. seosorted.ai provides free SEO tools that can support a broader quality-assurance workflow around content and technical deployment.
Errors, Warnings, and Eligibility Blockers
Fix these problems first:
- Invalid JSON.
- Missing commas, quotation marks, or braces.
- Trailing commas.
- Missing properties required for the targeted feature.
- Invalid property values.
- Incorrectly nested entities.
- Invalid URLs or date formats.
- Product offers attached to the wrong product.
- Reviews without an identifiable reviewed item.
- Markup that contradicts visible content.
Warnings often concern recommended rather than required properties. A warning may indicate that an entity could be more complete without blocking validation.
Do not chase a zero-warning score without understanding your objective. Adding irrelevant or fabricated values to silence warnings makes the data less reliable.
Prioritize issues in this order:
- Syntax failures.
- Required-property errors.
- Policy and visible-content conflicts.
- Incorrect entity relationships.
- Dynamic-data inaccuracies.
- Relevant recommended properties.
- Generic warnings unrelated to your objective.
Why Valid Schema May Not Produce a Rich Result
A validator pass proves only part of the implementation. A page can contain valid JSON-LD and still receive an ordinary search result.
Possible reasons include:
- The search engine does not support that type as a current rich result.
- The page type is not eligible.
- The implementation conflicts with current feature requirements.
- Required information is missing for the targeted feature.
- Structured data conflicts with visible content.
- The page is blocked, canonicalized elsewhere, unindexed, or not yet recrawled.
- The query does not trigger that presentation.
- Device, language, country, or testing conditions differ.
- The search engine chooses not to display the enhancement.
Eligibility is not a display commitment. Do not respond to a missing rich result by adding every related schema type you can find. Diagnose the specific eligibility path and verify the page instead.
Testing JavaScript-Injected Structured Data
If JavaScript injects your JSON-LD, confirm that it appears reliably in the rendered HTML. Test fresh sessions, mobile rendering, consent states, and slower execution conditions.
Check for:
- Incorrectly escaped quotation marks.
- Truncated descriptions.
- Unwanted HTML entities.
- Race conditions.
- Scripts that execute only after interaction.
- Consent systems that block the markup.
- Different entities shown to crawlers and users.
- Client-side navigation that leaves old schema in place.
- Duplicate blocks created during hydration or route changes.
Schema should not depend on a button click, tab opening, or delayed event. If injection is unstable or difficult to diagnose, prefer dependable server-rendered or template-generated output.
Common Schema Markup Mistakes Found in Audits
The most damaging schema problems are usually operational failures rather than obscure vocabulary issues. Multiple systems produce the same entity, dynamic values drift out of date, or the markup describes content users cannot see.
For each issue, ask four questions:
- Symptom: What appears in the rendered output?
- Risk: What ambiguity or eligibility problem can it create?
- Diagnosis: Which system and data source produced it?
- Fix: How will you prevent it from returning?
More markup is not better. A small, connected, accurate entity graph is safer than indiscriminate generation.
Duplicate or Conflicting Entities
Symptom: A page contains two Organizations, Products, Articles, or breadcrumb trails that appear to describe the same thing.
One Organization might use https://www.example.com/#organization, while another uses https://example.com/#company. Their names, logos, profiles, or URLs may differ.
A Product page might contain one Offer from the theme and another from an app, with conflicting prices or availability.
Risk: Conflicting statements make it unclear which entity or property is authoritative. They can also undermine feature eligibility when important commercial values disagree.
Diagnosis: Inventory every JSON-LD block and trace it to a plugin, theme component, app, custom template, or tag-manager injection. Compare each @id, URL, and dynamic property.
Fix: Consolidate generators or disable overlapping output. If separate blocks are legitimate, reference the same stable identifiers and ensure the facts agree.
Do not remove valid nested entities merely because a type appears more than once. An Article can reference an Organization defined elsewhere, and a Product can contain an Offer.
Markup That Does Not Match Visible Content
Symptom: The JSON-LD contains information users cannot inspect or values that differ from the page.
Common examples include:
- FAQ answers absent from the page.
- Review ratings without visible reviews.
- Outdated product prices.
- Incorrect stock status.
- Unsupported aggregate ratings.
- HowTo steps missing from the article.
- Opening hours that differ from the location page.
- An author name that differs from the byline.
Risk: The page can lose feature eligibility or communicate unsupported claims to search systems.
Diagnosis: Compare every meaningful property with visible text and authoritative CMS, commerce, review, or location records.
Fix: Generate structured data from the same source that controls the visible information. When a price, answer, rating, or opening time changes, both outputs should update together.
Structured data should describe the page users receive. It should not contain a more flattering or keyword-heavy version available only to machines.
Broken Identifiers, URLs, and Nesting
Symptom: Entities use relative URLs, redirected URLs, staging domains, or the same @id for different things. Offers, authors, publishers, and reviewed items may also be attached at the wrong level.
Examples include:
- A Product
@idcopied to every product page. - An Organization identifier reused for a business location.
- An Article pointing to a noncanonical URL.
- A Review without
itemReviewed. - An author represented as plain text in one block and a conflicting Person elsewhere.
- An Offer disconnected from its Product.
Risk: Broken identity and nesting prevent machines from connecting the intended entities. Canonical conflicts also make it unclear which URL represents the page or object.
Diagnosis: Map every @id, canonical URL, and relationship. Check redirects, status codes, hostnames, protocols, and fragment conventions.
Fix: Use stable absolute URLs and assign identifiers intentionally. Validate representative templates after domain migrations, redesigns, URL changes, and taxonomy updates.
An @id is an identity key, not a decorative URL. Do not change it casually after using it consistently across your site.
Applying Schema to the Wrong Page Template
Symptom: A schema type appears on a page that does not primarily represent that entity.
Frequent examples include:
- Product markup on a category listing.
- Article markup on a sales landing page.
- Review markup on an unverified testimonial carousel.
- LocalBusiness markup for locations that do not exist.
- FAQPage markup on pages without visible questions and answers.
- HowTo markup on articles without an ordered process.
Risk: The implementation misrepresents the page and may fail eligibility checks.
Diagnosis: Identify the page’s main purpose before considering the search enhancement you want. Then confirm that the necessary supporting information exists on that template.
Fix: Use conditional template logic. Output a type only on pages where the entity exists and the required data is available.
Choose the main entity based on what the page is, not the result format you want.
Failing to Maintain Dynamic Values
Symptom: Markup is correct at launch but becomes stale after routine business changes.
High-risk dynamic values include:
- Prices and sale prices.
- Currency.
- Availability.
- SKU and variant selection.
- Rating values and review counts.
- Publication and modification dates.
- Opening hours.
- Addresses and telephone numbers.
- Author roles and profile URLs.
- Brand names and logos.
Risk: Stale structured data contradicts the page and makes commercial information unreliable.
Diagnosis: Compare live markup with current source systems across representative templates. Review release history to find when values diverged.
Fix: Bind dynamic properties to authoritative records, define update triggers, and retest after releases. Assign an owner and rollback procedure for every scaled deployment.
Your ownership checklist should record:
- Each page template using schema.
- The main and supporting entities.
- The generator responsible for each block.
- The source of every dynamic field.
- Stable
@idconventions. - Events that trigger updates.
- Pre-release validation steps.
- Post-release URL checks.
- Search Console monitoring.
- A named owner and rollback path.
Schema Markup Best Practices for Search and AI Systems
A durable schema strategy follows a clear hierarchy:
- Mark up facts users can verify.
- Choose the most specific accurate type.
- Start with the page’s main entity.
- Add supporting entities only when they clarify real relationships.
- Connect repeated entities through stable
@idvalues. - Use canonical absolute URLs.
- Keep dynamic values current.
- Test rendered production output.
- Monitor policies and documentation.
- Recheck representative templates after changes.
An article may need an Article, its Person author, an Organization publisher, and a BreadcrumbList. It does not need every remotely applicable CreativeWork subtype or an invented collection of entities designed to maximize validator output.
Consistent identifiers can help search and AI systems distinguish your brand from similarly named organizations, connect an author to their work, or associate an offer with the correct product. They do not prove authority or guarantee that a platform will trust every stated fact.
Schema is one interpretive input. It cannot guarantee rankings, rich results, citations, recommendations, or inclusion in generated answers.
A Sensible Implementation Order
Use this sequence:
- Inventory the schema already present.
- Resolve duplicate and conflicting entities.
- Define canonical URLs and stable
@idconventions. - Identify the main entity for each page template.
- Connect fields to authoritative data sources.
- Deploy on a limited set of representative pages.
- Validate syntax, vocabulary, eligibility, and rendered output.
- Expand to the full template after quality checks.
- Monitor production output and Search Console.
- Retest after platform or content-model changes.
For ecommerce sites, prioritize accurate Product and Offer data on product pages. Commercial data changes frequently, so source integration and maintenance matter more than optional vocabulary.
For editorial sites, implement Article with dependable authorship, publication details, publisher references, and canonical URLs. BreadcrumbList can clarify hierarchy across editorial and commercial architectures.
Define Organization or LocalBusiness entities where they reflect the real business. Use FAQPage, HowTo, and Review only when the visible content and current feature requirements justify them.
At scale, the challenge is not producing JSON once. It is keeping research, page content, metadata, internal links, schema, publishing, and monitoring aligned. An integrated content workflow is more useful than a disconnected generator.
What Schema May Do for AI—and What Is Hype
Schema can help a machine interpret explicit entities and relationships. It can state that a named person authored an article published by a particular organization or that an offer belongs to a specific product.
That clarity does not establish that an AI platform will accept the claims, select the page as a source, or display a citation.
AI systems may use:
- Indexed page content.
- Structured data.
- External references.
- First-party databases.
- Product feeds.
- Knowledge graphs.
- Retrieval systems.
- User context.
- Quality and trust evaluations.
- Platform-specific data arrangements.
They are not obligated to consume or trust your schema. Adding numerous types does not automatically improve AI visibility, and no schema markup generator can guarantee citations.
Treat entity clarity as sensible technical hygiene. Treat promises of guaranteed AI mentions as marketing hype.
Schema Markup Questions, Answered
What Is Schema Markup?
Schema markup is machine-readable code that labels the entities, facts, and relationships described on a webpage using a shared vocabulary. The examples in this guide use JSON-LD to apply that vocabulary.
Can You Give Me an Example of Schema Markup?
The eight templates above cover Article, FAQPage, HowTo, Product, Organization, LocalBusiness, BreadcrumbList, and Review. A small Organization block containing @context, @type, @id, name, and url is a useful starting pattern.
Replace every example value with accurate information and preserve valid JSON syntax. Never leave example domains, prices, authors, or ratings in production.
Does Schema Markup Improve Rankings?
Schema markup is not a direct ranking boost. Its practical SEO value comes from eligibility for supported search features, clearer entity relationships, and reduced ambiguity.
Your page still needs relevant content, technical accessibility, internal links, authority, and other quality signals. Structured data cannot compensate for a weak page.
Does Valid Schema Guarantee a Rich Result?
No. Valid syntax is only one gate.
The type must be supported for the intended feature, the page must meet current requirements, the content must be consistent, and the URL must be accessible to the search engine. Query context and the search engine’s display decisions also affect the outcome.
Should You Use a Schema Markup Generator?
A generator can produce a useful first draft for standard JSON-LD structures. It cannot verify your business facts, page-template fit, existing duplicates, visible-content alignment, or future data accuracy.
Validate the output, inspect the rendered production page, and compare each important value with its authoritative source before deployment.
How Often Should You Check Schema Markup?
Retest after changes to templates, plugins, apps, themes, CMS fields, content models, prices, inventory, reviews, locations, domains, or canonical URLs. Migrations and redesigns also require structured-data checks.
Schedule recurring tests for representative page types and frequently changing commercial fields. Reliable template-level audits can reduce the need to test every static URL manually.
FAQ
Can Schema Markup Be Placed in the Page Body?
Yes. JSON-LD can appear in the page HTML as a properly formed application/ld+json script block. Confirm that the block appears on the production URL, describes that page accurately, and does not conflict with another generator.
Should Every Page Contain Organization Schema?
Not necessarily. Your site should describe the organization consistently, but a complete Organization block does not always need to be repeated on every page. Supporting entities can reference one stable Organization @id.
If your platform repeats the entity sitewide, make sure each copy uses the same identifier and facts.
Is Microdata Better Than JSON-LD?
Both formats can express Schema.org vocabulary, but JSON-LD keeps structured data separate from visible HTML and is often easier to generate, inspect, and update. The best format is one your team can deploy accurately without duplication or stale values.
Can Hidden Content Be Included in Schema Markup?
Structured data should describe content users can access on the page. Content in a normal expandable component may be accessible, but information stored only in JSON-LD creates a mismatch. Do not hide reviews, FAQs, instructions, prices, or ratings from users while exposing them to search systems.
How Do You Know Whether Schema Markup Is Working?
Check four things separately: valid JSON, Schema.org conformance, Google feature eligibility, and live search presentation. Use rendered HTML inspection, the Schema.org Validator, Google’s Rich Results Test, and relevant Search Console reports.
Even when every technical check passes, a search engine may choose not to display an enhancement.
Build Schema Into a Repeatable SEO Workflow
Use these templates to define accurate entities, then make validation and maintenance part of publishing rather than a one-time technical task. To automate research, content creation, publishing, and ongoing SEO checks across WordPress, Webflow, or Shopify, explore seosorted.ai.
FREE BACKLINK PLAN
Build authority with backlinks that matter
Get a shortlist of sites that already link to competitors in your niche, ranked by authority, without doing the outreach research yourself.
- 20 link opportunities matched to your niche
- Discover competitor backlink sources
- Get actionable link-building opportunities

We'll email you the results and occasional SEO tips. Unsubscribe anytime.
Common questions
The core research-and-write loop is similar - both start from real SERP data and match your brand voice. The practical difference shows up in volume and what happens after publishing: SEO Sorted includes 30 articles a month at the $99 price point with add-on tiers if you need more, and it feeds Search Console performance data back in to improve future articles. Outrank currently has a live backlink exchange; SEO Sorted's is on the roadmap.
Typically 3–6 months before articles start climbing Google significantly — that's the nature of SEO, not something specific to seosorted. The compounding effect is the point: publishing consistently from day one means you're months ahead of starting later. Sites that publish 8–12 articles in the first 60 days consistently see their first rankings within 90 days. Every week without content is a week of organic traffic going to a competitor who is publishing.
Yes, always. Every article lands in a READY state first — you can read it, edit it, approve it, or reject it before anything goes live. If you'd rather not touch it, you can turn on auto-publish and articles go straight to your CMS on your chosen schedule. Full control or full autopilot — your call per article.
WordPress, Webflow, and Shopify natively — the article, featured image, meta description, and schema markup all land in your CMS automatically. For everything else — Ghost, Sanity, Strapi, Notion, or any custom headless setup — we publish via Webhook. We POST a JSON payload with the full article, SEO fields, images, and schema. If your CMS accepts a POST request, we can publish to it.
Related Blogs

B2B SEO: A Practical Strategy for Turning Search Visibility Into Pipeline
Build a B2B SEO system that aligns buyer intent, credible content, technical foundations, and revenue measurement to generate more pipeline. See how.
Updated on
Nov 13, 2026
9 min read



