If a theme and a plugin both output schema for the same page, the fix runs in a fixed order. Find every block in the live HTML, decide which system owns each entity, switch off the overlapping output where it is generated, and retest. The aim is one owner for each entity, not one block per page.

Several blocks on one page are normal. A page can describe an article, its author and its breadcrumb trail as separate items. The trouble starts when two systems describe the same entity, often with different headlines, dates or prices. Google says it understands multiple items on a page, whether nested or declared separately, and its guidelines ask for complete, accurate markup that matches the visible content (Google general guidelines).

The same steps apply whether the site runs on WordPress, Shopify, Wix, Squarespace, Webflow, HubSpot, Next.js or hand-built code, with platform notes where the details differ. Start with the page source, then trace each block back to the file, plugin or app that prints it.

Key takeaways

  1. Several blocks can be fineDifferent entities such as an article, its author and a breadcrumb trail can share a page. Repeated or conflicting descriptions of one entity are the problem.
  2. One owner per entityUsually the SEO plugin owns sitewide and article data, the store owns Product and Offer, and a dedicated plugin covers only the gaps.
  3. Fix it at the sourceDisable overlapping output in the theme, plugin or app that prints it. Hiding a copy with CSS leaves the markup in the HTML.
  4. Test the live URLUse the Rich Results Test for Google features and the Schema Markup Validator for vocabulary, then Bing or Yandex tools where they matter.
  5. Stable @id valuesOne graph with fixed identifiers makes ownership easier to audit. It is a packaging choice, not a Google ranking requirement.

Find every schema block on the live page

Start with the page as visitors and crawlers receive it, not with a plugin settings screen. Open the affected URL in a browser, view the HTML source and search for application/ld+json, itemtype= and schema.org. The first catches JSON-LD scripts, the second catches Microdata attributes, and the third catches either format along with stray references.

Count every block and write down, for each one, the type, the @id, the URL, the name and the values that tend to drift: price, author and dates. A theme that prints an Article with one headline and a plugin that prints a second Article with a slightly different headline and a different dateModified is the pair that matters. Blocks of different types are not the problem.

Printing the blocks and laying them beside the open page makes disagreements easy to spot. Each value in the markup should match what a visitor can read on the page.

A woman in a burgundy denim jacket compares two printouts of boxes joined by arrows with an open laptop in a bike shop office
Figure 1. Printed blocks laid beside the open page make disagreeing values easy to spot.

View source shows the markup the server sent. Some frameworks add JSON-LD after JavaScript runs, so also inspect the rendered DOM in your browser's developer tools. Google recommends testing the URL rather than relying only on pasted code when JavaScript is involved (Google JavaScript structured data guidance).

Search Console's URL Inspection shows the version of the page Google retrieved, which you can compare with the current source once caches expire. Bing's URL Inspection includes a Markup card that can show JSON-LD, Microdata, Microformats and Open Graph on a URL (Bing URL Inspection). Yandex Webmaster offers a Structured Data Validator that recognizes Schema.org, Microformats, Open Graph, Microdata and RDFa.

Schema Nova's schema checker gives a quick look at the markup on a URL. Retrieved HTML is not the same as the rendered page, so pair it with the rendered DOM check when scripts add markup. For the basics of reading a page's markup, see how to check if a website has schema markup.

Why a theme and a plugin both print schema

Duplicates rarely come from one mistake. They build up as a site gains tools, and each tool assumes it is the only one describing the page. These are the usual causes:

  • a theme adds basic Article, WebSite or Product data;
  • an SEO plugin adds a connected graph for the same page;
  • a schema plugin adds another copy of the same type;
  • an ecommerce app and the theme both output product data;
  • a page builder injects custom JSON-LD;
  • a migration leaves old scripts active;
  • cached HTML still contains an earlier version;
  • server-rendered and client-rendered code both emit the same entity.

The last two deserve a second look before you change any settings. A cached page can show a block you already removed, and a framework that renders the same component on the server and again in the browser can print one entity twice. Clear the page cache and reload before you conclude that a plugin is the culprit.

Trace each block to the system that prints it

Every block has an emitter: a theme file, an SEO plugin, a schema plugin, an ecommerce system, a page builder or custom code. Compare each block you listed with those areas. On WordPress, look at the theme's header.php, single.php, template parts and any custom code, then at SEO plugins, schema plugins, WooCommerce, page builders and snippets added through a code-injection plugin.

The values give clues. A block whose headline, date or price differs from the SEO plugin's output usually comes from another emitter, and naming patterns in @id values can hint at which one. When the origin is still unclear, switch off one candidate at a time on a staging copy, reload the page source and see which block disappears.

Keep the list from the first step open as you go. By the end you want each entity on the page tied to exactly one emitter, even if that means writing a note for blocks you cannot yet explain.

Choose one owner for each entity

An owner is the single system responsible for describing an entity, and the rest stay out of it. Pick owners by what each tool already does well rather than by which one printed the block first. A sensible default is to let the SEO plugin own sitewide Organization, WebSite, WebPage, Article and breadcrumbs, let the ecommerce system own Product, Offer and inventory data, and use a dedicated schema plugin only for types the others do not provide.

Five entity tiles each joined by a single line to one of three owner tiles, with no tile receiving two lines
Figure 2. Each entity has one owner, so no two systems describe the same thing.

Once an owner is chosen, disable the overlapping output at its original source. Do not hide a copy with CSS or add a third block to reconcile the first two; the markup stays in the HTML either way, and every extra copy is another value that can drift out of date. Removing output at the source also keeps the fix in place when the theme or plugin updates.

Schema markup on WordPress covers what a typical site already outputs, and Yoast versus Rank Math schema compares two plugins that each build a connected graph.

Fix the overlap on your platform

The controls differ by platform, and menus change between releases. Confirm the current controls in your own account or theme before removing anything, and change one emitter at a time so you can tell which change did what.

WordPress and Yoast SEO

Review the theme files and plugins listed above first. Yoast documents a schema system that builds a connected graph, so review its Schema settings before adding another generator. If another system has been deliberately chosen as the owner of everything, Yoast's developer documentation provides a filter that stops its frontend JSON-LD (Yoast Schema API).

php
add_filter( 'wpseo_json_ld_output', '__return_false' );

Add that line to a child theme's functions.php or a snippet plugin only when the replacement output is complete and accurate. It switches off every Yoast schema node on the site, so a page left without an owner for Organization or breadcrumbs is a likely side effect.

If only one piece overlaps, the wpseo_schema_graph_pieces filter can change individual pieces instead. This example removes Yoast's breadcrumb piece, for a site where another system owns breadcrumbs.

php
add_filter( 'wpseo_schema_graph_pieces', 'example_remove_breadcrumb_piece', 11, 2 );

function example_remove_breadcrumb_piece( $pieces, $context ) {
    return array_filter( $pieces, function ( $piece ) {
        return ! $piece instanceof \Yoast\WP\SEO\Generators\Schema\Breadcrumb;
    } );
}

Replace the class name to target a different piece, and read the Yoast Schema API pages before relying on a class name after an update.

Shopify

Inspect the active theme's Liquid files, especially the layout, the product template and any product JSON-LD snippets. Then check installed SEO, review, product-feed and schema apps. Shopify's theme documentation requires themes to include SEO metadata and product snippets, so theme-native output has to be considered before custom product JSON-LD is added (Shopify theme requirements).

Remove or disable only the overlapping app or theme output, and keep one product entity in step with the visible name, price, availability, images and variants. Recheck after any theme change, because themes and apps can both add markup. The Shopify schema guide and the product schema guide go further.

Wix

Wix creates preset markup for products, blog posts, events and other page types, so review SEO Settings, then the Advanced area, then Structured data markup before adding custom JSON-LD. If Wix already supplies the same entity, edit or remove the custom block. Wix documents JSON-LD for custom structured data and lets you edit or delete page-level markup in the SEO settings (Wix preset markups, Wix structured-data troubleshooting). The Wix guide covers the interface in more detail.

Squarespace

Review page-level code injection, header and footer injection, template files and installed integrations. Compare any custom JSON-LD with the page's published output and keep one description of each entity. Confirm the current controls in your Squarespace account before removing a block. The Squarespace guide has the installation routes.

Webflow

Check page settings, project custom code, Embed elements and CMS-driven templates. Webflow custom code renders after publishing and can conflict with platform output, so inspect the published page rather than the Designer preview (Webflow custom code embed). See the Webflow guide for where each kind of code goes.

HubSpot

Check the page or blog template, site-header HTML, modules, HubDB-driven components and connected SEO integrations. Remove custom JSON-LD that duplicates what HubSpot or an installed integration prints, then confirm the published HTML after deployment. Confirm current controls in your HubSpot account before deleting anything; the HubSpot guide lists the places to look.

Next.js and hand-built sites

Search layout.js, page.js, route layouts, shared components and CMS-rendered components for JSON-LD. Render one graph at the page or layout level, and escape < when serializing data that changes per page, as Next.js recommends to reduce XSS risk (Next.js JSON-LD guidance).

js
const jsonLd = { '@context': 'https://schema.org', '@graph': [] };

export default function Page() {
  return (
    <script
      type="application/ld+json"
      dangerouslySetInnerHTML={{
        __html: JSON.stringify(jsonLd).replace(/</g, '\\u003c'),
      }}
    />
  );
}

Put your real nodes in the @graph array and keep that component in one place so a layout and a page do not both print it. The JSON-LD in Next.js and React guide shows fuller patterns.

Combine the remaining nodes into one graph

Once each entity has an owner, one JSON-LD script can hold all of them as connected nodes. JSON-LD is a format for writing structured data as linked data, and Schema.org supplies the vocabulary of types and properties. An @id gives an entity a stable identifier, usually the canonical URL plus a fragment such as #article or #organization, and reusing the same @id lets separate nodes refer to the same entity. The W3C defines node objects, identifiers and @graph in JSON-LD 1.1.

This fictional graph joins an organization, a website, a post, its author and a breadcrumb trail with @id references.

json
{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "Organization",
      "@id": "https://example.com/#organization",
      "name": "Example Publishing Group",
      "url": "https://example.com/",
      "logo": { "@type": "ImageObject", "url": "https://example.com/images/example-logo.png" }
    },
    {
      "@type": "WebSite",
      "@id": "https://example.com/#website",
      "url": "https://example.com/",
      "name": "Example Publishing Group",
      "publisher": { "@id": "https://example.com/#organization" }
    },
    {
      "@type": "BlogPosting",
      "@id": "https://example.com/duplicate-schema-guide/#article",
      "url": "https://example.com/duplicate-schema-guide/",
      "headline": "Duplicate Schema From Plugins and Themes",
      "image": ["https://example.com/images/duplicate-schema-guide.jpg"],
      "datePublished": "2026-10-15",
      "dateModified": "2026-10-20",
      "author": { "@id": "https://example.com/authors/example-author/#person" },
      "publisher": { "@id": "https://example.com/#organization" },
      "mainEntityOfPage": { "@id": "https://example.com/duplicate-schema-guide/" },
      "isPartOf": { "@id": "https://example.com/#website" }
    },
    {
      "@type": "Person",
      "@id": "https://example.com/authors/example-author/#person",
      "name": "Example Author",
      "url": "https://example.com/authors/example-author/"
    },
    {
      "@type": "BreadcrumbList",
      "@id": "https://example.com/duplicate-schema-guide/#breadcrumb",
      "itemListElement": [
        { "@type": "ListItem", "position": 1, "name": "Home", "item": "https://example.com/" },
        { "@type": "ListItem", "position": 2, "name": "Guides", "item": "https://example.com/guides/" },
        { "@type": "ListItem", "position": 3, "name": "Duplicate Schema From Plugins and Themes" }
      ]
    }
  ]
}

Replace every value with information that is true and visible on your page, and keep the @id values stable so other nodes can point to them. This graph is a packaging and identity choice, not a Google ranking requirement. Separate JSON-LD scripts can also be valid; consolidation mainly reduces accidental duplication and makes ownership easier to audit. The JSON-LD graph guide explains how nodes connect.

Which properties matter depends on the consumer. For Google, the Article guide lists recommended properties but no required ones, the Breadcrumb guide requires itemListElement with position and name on each ListItem, and the Organization guide lists no required properties, with name, url, logo and sameAs recommended where they apply (Google Article, Google Breadcrumb, Google Organization).

Required and recommended properties in a consolidated graph

Hover over or tap a row to highlight it. On small screens the table scrolls sideways.

PropertyStatusQualification
itemListElement on BreadcrumbListRequired for Google BreadcrumbAt least two breadcrumb items are needed
position and name on each ListItemRequired for Google BreadcrumbPosition is an integer starting at 1; the final item may take its name from the page
item on non-final itemsRequired for Google BreadcrumbThe final breadcrumb item may omit item
author, datePublished, dateModifiedRecommended for Google ArticleUse an identifiable author, the actual publication date, and a modified date only when maintained
image and publisherRecommended for Google ArticleUse a crawlable image; connect the publisher to the authoritative organization node
@idOptional for the listed Google featuresStrongly useful for connecting nodes and preventing ambiguity

Retest the live page after the change

Clear page, CDN and browser caches first, then test the live URL rather than pasted code. Google's Rich Results Test shows Google-supported rich-result types, parsing errors and eligibility signals, and eligibility does not guarantee that Google shows a rich result. The Schema Markup Validator inspects Schema.org vocabulary independently of Google Search features, so it can check types that Google does not use for a rich result (Google structured-data testing).

The two tools answer different questions. Rich Results Test versus Schema Markup Validator explains which to use when, and Schema Nova's validator is another way to check JSON syntax and vocabulary. If a warning remains after cleanup, fixing missing field warnings covers the common ones.

Then recheck the rendered page source, count the blocks again against your list, and request recrawling in Search Console when appropriate. Check Bing's Markup card or Yandex's validator if those engines matter to your audience. If the markup is clean but no enhancement appears, why rich results are not showing covers eligibility and display.

Duplicate schema cleanup sequence

  1. InspectView the page source, search for application/ld+json, itemtype and schema.org, and list each block's type, @id, URL and values.
  2. TraceMatch each block to the theme, SEO plugin, schema plugin, app or custom code that prints it.
  3. Choose ownersPick one owner for each entity and group nodes by @id, URL and name.
  4. Disable overlapSwitch off the overlapping output at its origin rather than hiding it.
  5. Clear cachesClear page, CDN and browser caches before you test.
  6. RetestUse the Rich Results Test and Schema Markup Validator, then Bing or Yandex tools where those engines matter.

Bing supports Schema.org in JSON-LD and Microdata, along with Microformats, RDFa and Open Graph (Bing structured data), so the single owner you chose serves Bing too. Microsoft says Copilot web search sends generated queries to Bing to ground responses (Microsoft Copilot web access), so confirm the page in Bing's Markup card. Yandex's validator recognizes Schema.org and other markup formats (Yandex semantic-markup FAQ).

For ChatGPT, Perplexity and DuckDuckGo, keep pages crawlable with clear visible answers, stable URLs and accurate entities. For the wider question, see whether AI systems use schema markup. The best practices checklist and the rich results guide cover the wider picture.

Questions people ask

Can a theme and a plugin both add schema markup?

Yes. Themes, SEO plugins, ecommerce systems, page builders and custom code can each emit structured data. That is why the live HTML is the place to look, rather than any one settings screen.

Is duplicate schema always an error?

No. Different entities can legitimately share a page, such as an article, its author and its breadcrumb trail. Repeated descriptions of the same entity, especially with conflicting values, should be consolidated under one owner.

Does duplicate schema cause a Google penalty?

Duplicate output alone is not documented as an automatic penalty. Inaccurate, misleading or conflicting markup can create eligibility and interpretation problems, so keep one authoritative node per entity and match every value to the visible page.

Should I turn off schema in my SEO plugin?

Only if you have deliberately chosen another system as the owner and its output is complete and accurate. Otherwise leave the SEO plugin in charge and remove the overlap from the theme or the extra plugin.

Can I put several entities in one JSON-LD block?

Yes. Use @graph and stable @id values to connect the nodes. Separate scripts can also be valid, so choose whichever your platform can keep consistent.

Quick check: duplicate or legitimate?

Choose an answer to see feedback. Nothing is scored or saved.

Question 1 of 3

A page has one Article, one Person author, one Organization publisher and one BreadcrumbList. Is that automatically duplicate schema?

Question 2 of 3

A theme and an SEO plugin each output an Article for the same URL, with different headlines and dates. What is the safest fix?

Question 3 of 3

Does a valid FAQPage type guarantee FAQ rich results in Google?

Glossary

Select a term to see its definition.

Entity. A real or conceptual thing being described, such as an article, organization or product.