{"id":379,"date":"2026-01-26T09:01:32","date_gmt":"2026-01-26T09:01:32","guid":{"rendered":"https:\/\/hetneo.link\/blog\/where-schema-markup-actually-goes-and-why-placement-matters-for-entity-recognition\/"},"modified":"2026-05-16T04:17:22","modified_gmt":"2026-05-16T04:17:22","slug":"where-schema-markup-actually-goes-and-why-placement-matters-for-entity-recognition","status":"publish","type":"post","link":"https:\/\/hetneo.link\/blog\/where-schema-markup-actually-goes-and-why-placement-matters-for-entity-recognition\/","title":{"rendered":"Where Schema Markup Actually Goes (And Why Placement Matters for Entity Recognition)"},"content":{"rendered":"<p>Schema markup belongs in the `<head>` as JSON-LD, that&#8217;s the short answer Google has given us for years. The longer answer is that placement is a per-entity decision: site-wide schemas (Organization, WebSite, SearchAction) live in the template header, page-specific schemas (Article, Product, Event) get injected dynamically into each page&#8217;s head, and a narrow subset (BreadcrumbList, LocalBusiness when it describes visible content) sometimes earns a spot in the body. This guide walks through where each schema type goes, why the placement matters for entity recognition, and the validation step that catches the silent failures most teams miss.<\/p>\n<aside style=\"border-left:4px solid #1F2A44;background:#F4F6FB;padding:18px 22px;margin:28px 0;border-radius:4px;\">\n<p style=\"margin:0 0 8px;font-weight:700;letter-spacing:.04em;text-transform:uppercase;font-size:.78em;color:#1F2A44;\">Key takeaways<\/p>\n<ul style=\"margin:0;padding-left:20px;\">\n<li>Google reads JSON-LD in either the head or just before the closing body tag, but head placement is the documented recommendation and the cleanest pattern at scale.<\/li>\n<li>Site-wide entities (Organization, WebSite, SearchAction) belong in the template header, page-specific entities (Article, Product, Event) get injected dynamically into the head of each page.<\/li>\n<li>Inline microdata and RDFa still work, but they couple structured data to visible markup, which means a CMS edit can silently break your schema.<\/li>\n<li>Splitting one entity&#8217;s properties across two `<script>` blocks is the most common placement bug, consolidate each entity into a single JSON-LD object.<\/li>\n<li>Test placement in Rich Results Test immediately after deploy, schema that validates statically can still fail when JavaScript injects it after the parser has moved on.<\/li>\n<\/ul>\n<\/aside>\n<h2>The Two Types of Schema Placement<\/h2>\n<p>So there's a deceptively simple choice at the heart of every schema deployment: head or body, JSON-LD or inline. Most teams pick wrong because they pick once and apply it everywhere (I did this for two years on a client account, inline microdata everywhere, until a theme update silently nuked half the Product schema overnight). The honest answer is that the right placement depends on what the schema describes and whether the page's markup is stable enough for inline binding to survive a content edit.<\/p>\n<div style=\"background:#F8F9FC;border:1px solid #d8dde8;border-radius:6px;padding:20px 24px;margin:28px 0;\">\n<p style=\"margin:0 0 14px;font-weight:700;letter-spacing:.04em;text-transform:uppercase;font-size:.78em;color:#1F2A44;\">Quick vocabulary<\/p>\n<dl style=\"margin:0;display:grid;grid-template-columns:max-content 1fr;gap:10px 22px;\">\n<dt style=\"font-weight:600;color:#1F2A44;\">Head placement<\/dt>\n<dd style=\"margin:0;\">A `<script type=\"application\/ld+json\">` block inside the document `<head>`, the documented Google recommendation for JSON-LD.<\/dd>\n<dt style=\"font-weight:600;color:#1F2A44;\">Body placement<\/dt>\n<dd style=\"margin:0;\">The same JSON-LD `<script>` block placed inside `<body>`, usually just before `<\/body>`. Valid, but treated as a fallback rather than a preference.<\/dd>\n<dt style=\"font-weight:600;color:#1F2A44;\">Inline JSON-LD<\/dt>\n<dd style=\"margin:0;\">JSON-LD embedded directly in the page source by the server or CMS, as opposed to injected client-side via JavaScript.<\/dd>\n<dt style=\"font-weight:600;color:#1F2A44;\">External script<\/dt>\n<dd style=\"margin:0;\">JSON-LD loaded from a separate URL via `<script src=\"...\">`, technically possible but discouraged, Googlebot does not always fetch and merge it on time.<\/dd>\n<dt style=\"font-weight:600;color:#1F2A44;\">Microdata<\/dt>\n<dd style=\"margin:0;\">Inline structured data using `itemscope`, `itemtype`, and `itemprop` attributes on existing HTML elements. Couples schema to visible markup.<\/dd>\n<dt style=\"font-weight:600;color:#1F2A44;\">RDFa<\/dt>\n<dd style=\"margin:0;\">A second inline format using `vocab`, `typeof`, and `property` attributes. Functionally similar to microdata, less common in modern stacks.<\/dd>\n<\/dl>\n<\/div>\n<h3>Head-embedded schema (JSON-LD)<\/h3>\n<p>JSON-LD scripts typically belong in the `<head>` section, though placing them at the end of `<body>` also works, Google reads both. This method excels for site-wide entities like Organization, WebSite, and SearchAction schemas that describe your whole domain rather than specific on-page content. Because JSON-LD lives in a `<script type=\"application\/ld+json\">` block separate from visible HTML, it sidesteps the messiness of wrapping semantic markup around text and images.<\/p>\n<div style=\"border-left:3px solid #4A90B8;background:#EEF5FA;padding:14px 18px;margin:24px 0;border-radius:0 4px 4px 0;\">\n<p style=\"margin:0 0 4px;font-size:.78em;font-weight:700;letter-spacing:.06em;text-transform:uppercase;color:#1F4A66;\">Pro tip<\/p>\n<p style=\"margin:0;\">If your stack injects JSON-LD via JavaScript after the page loads, render it server-side or via SSR\/SSG instead. Googlebot will execute JS, but Bing, Yandex, and most LLM crawlers stop at the static HTML. Head-rendered JSON-LD in the initial response is the only placement that all parsers consistently see on first pass.<\/p>\n<\/div>\n<p>Why it matters: JSON-LD decouples structured data from page layout, making implementation cleaner for developers and easier to validate independently. Search engines parse it reliably without navigating DOM complexity. Mostly. There are edge cases where a poorly-formed JSON-LD block gets dropped silently, but as a default it's the safest call. Use this approach when your schema describes metadata, business details, sitewide search functionality, or breadcrumb navigation, rather than content blocks users see. It's the recommended format in <a href=\"https:\/\/developers.google.com\/search\/docs\/appearance\/structured-data\/intro-structured-data\" rel=\"noopener\">Google's structured data guidelines<\/a> for precisely this reason: it doesn't interfere with frontend code, plays well with content management systems, and reduces the risk of breaking page rendering when schemas change. (Backlinko's <a href=\"https:\/\/backlinko.com\/hub\/seo\/schema\" rel=\"noopener\">schema overview<\/a> reaches the same conclusion from a different angle, JSON-LD is the default because it's the format least likely to silently break when someone else touches the template.)<\/p>\n<p>A minimal head-placed Organization block looks like this:<\/p>\n<figure style=\"margin:24px 0;\">\n<pre style=\"background:#0F172A;color:#E2E8F0;padding:18px 20px;border-radius:8px;overflow-x:auto;font-size:.88em;line-height:1.55;margin:0;\"><code>&lt;head&gt;\n  &lt;title&gt;Your Page Title&lt;\/title&gt;\n  &lt;link rel=\"canonical\" href=\"https:\/\/example.com\/\"&gt;\n  &lt;script type=\"application\/ld+json\"&gt;\n  {\n    \"@context\": \"https:\/\/schema.org\",\n    \"@type\": \"Organization\",\n    \"@id\": \"https:\/\/example.com\/#organization\",\n    \"name\": \"Example Co\",\n    \"url\": \"https:\/\/example.com\",\n    \"logo\": \"https:\/\/example.com\/logo.png\",\n    \"sameAs\": [\n      \"https:\/\/www.linkedin.com\/company\/example\",\n      \"https:\/\/twitter.com\/example\"\n    ]\n  }\n  &lt;\/script&gt;\n&lt;\/head&gt;<\/code><\/pre><figcaption style=\"text-align:center;color:#6a7280;font-size:.88em;margin-top:8px;\">A minimal head-placed Organization schema. Note the stable @id, that's the anchor every other entity on the site will reference.<\/figcaption><\/figure>\n<h3>Inline schema (Microdata and RDFa)<\/h3>\n<p>Inline schema wraps HTML elements with RDFa or Microdata attributes, embedding structured data directly into the markup that renders visible content. Place it where the human-readable text and the corresponding entity live, product prices, article headlines, breadcrumb trails, local business addresses, so search engines parse both presentation and semantics in a single pass. Or rather, that's the theory. In practice the \"single pass\" part is mostly true for Google and increasingly unreliable everywhere else.<\/p>\n<p>Why it's interesting: tight coupling between markup and content reduces drift when editors update copy. Crawlers match structured claims to what users actually see, which strengthens entity signals for Knowledge Graph alignment. Honestly, that's the strongest argument for inline, alignment is automatic when the schema is welded to the visible DOM.<\/p>\n<p>For: developers maintaining product catalogs, news sites, or multi-location business pages where content changes frequently and markup must stay synchronized. Moz's <a href=\"https:\/\/moz.com\/learn\/seo\/schema-structured-data\" rel=\"noopener\">structured data guide<\/a> notes that microdata still has its place on legacy templates where retrofitting head-level JSON-LD would require touching every page, but for new builds JSON-LD is the practical default.<\/p>\n<figure class=\"wp-block-image size-large\">\n<img loading=\"lazy\" decoding=\"async\" width=\"900\" height=\"514\" src=\"https:\/\/hetneo.link\/blog\/wp-content\/uploads\/2026\/01\/schema-markup-code-placement.jpg\" alt=\"Overhead view of laptop showing HTML code with schema markup in development environment\" class=\"wp-image-376\" srcset=\"https:\/\/hetneo.link\/blog\/wp-content\/uploads\/2026\/01\/schema-markup-code-placement.jpg 900w, https:\/\/hetneo.link\/blog\/wp-content\/uploads\/2026\/01\/schema-markup-code-placement-300x171.jpg 300w, https:\/\/hetneo.link\/blog\/wp-content\/uploads\/2026\/01\/schema-markup-code-placement-768x439.jpg 768w\" sizes=\"auto, (max-width: 900px) 100vw, 900px\" \/><figcaption>Schema markup placement decisions affect how search engines extract and recognize entities from your website's code structure.<\/figcaption><\/figure>\n<p>Best candidates include Article schema on blog posts (headline, author, datePublished attributes on existing h1 and byline elements), Product schema on e-commerce detail pages (price, availability wrapping the display spans), BreadcrumbList on navigation trails, and LocalBusiness schema on contact pages. Inline placement ensures visible text and structured assertions share the same DOM nodes, making inconsistencies immediately obvious during QA and minimizing the risk of contradictory signals that confuse entity resolution.<\/p>\n<figure class=\"wp-block-pullquote\" style=\"border-top:4px solid #1F2A44;border-bottom:4px solid #1F2A44;padding:28px 0;margin:36px 0;text-align:center;\">\n<blockquote style=\"margin:0;padding:0;border:none;\">\n<p style=\"font-size:1.35em;line-height:1.45;font-style:italic;color:#1F2A44;margin:0;\">Head placement makes the schema durable. Inline placement makes the schema honest. Pick the trade-off that matches the page.<\/p>\n<\/blockquote>\n<\/figure>\n<h2>Placement Options vs Google's Parsing Behavior<\/h2>\n<p>The four placement patterns are not interchangeable, Google's parsers treat each one slightly differently. In most cases the differences don't matter, but on the edges (JS-injected schema, external scripts, mixed formats on the same page) they absolutely do.<\/p>\n<figure class=\"wp-block-table\" style=\"margin:24px 0;\">\n<table style=\"width:100%;border-collapse:collapse;font-size:.95em;\">\n<thead>\n<tr style=\"background:#1F2A44;color:#fff;\">\n<th style=\"padding:10px 12px;text-align:left;border:1px solid #1F2A44;\">Placement<\/th>\n<th style=\"padding:10px 12px;text-align:left;border:1px solid #1F2A44;\">Google parses<\/th>\n<th style=\"padding:10px 12px;text-align:left;border:1px solid #1F2A44;\">Best for<\/th>\n<th style=\"padding:10px 12px;text-align:left;border:1px solid #1F2A44;\">Risk<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td style=\"padding:10px 12px;border:1px solid #d8dde8;font-weight:600;\">JSON-LD in `&lt;head&gt;`<\/td>\n<td style=\"padding:10px 12px;border:1px solid #d8dde8;\">Yes, documented recommendation<\/td>\n<td style=\"padding:10px 12px;border:1px solid #d8dde8;\">Site-wide entities (Organization, WebSite, SearchAction), Article, Product<\/td>\n<td style=\"padding:10px 12px;border:1px solid #d8dde8;\">Drift between schema and visible content if no QA process<\/td>\n<\/tr>\n<tr style=\"background:#F8F9FC;\">\n<td style=\"padding:10px 12px;border:1px solid #d8dde8;font-weight:600;\">JSON-LD before `&lt;\/body&gt;`<\/td>\n<td style=\"padding:10px 12px;border:1px solid #d8dde8;\">Yes, supported equivalently<\/td>\n<td style=\"padding:10px 12px;border:1px solid #d8dde8;\">CMS setups where head injection is locked down<\/td>\n<td style=\"padding:10px 12px;border:1px solid #d8dde8;\">Some non-Google parsers miss it if rendering is interrupted<\/td>\n<\/tr>\n<tr>\n<td style=\"padding:10px 12px;border:1px solid #d8dde8;font-weight:600;\">JS-injected JSON-LD<\/td>\n<td style=\"padding:10px 12px;border:1px solid #d8dde8;\">Yes after render, but second-pass<\/td>\n<td style=\"padding:10px 12px;border:1px solid #d8dde8;\">SPA shells, dynamic templates with no SSR option<\/td>\n<td style=\"padding:10px 12px;border:1px solid #d8dde8;\">Non-Google crawlers (Bing, LLM bots) often skip it<\/td>\n<\/tr>\n<tr style=\"background:#F8F9FC;\">\n<td style=\"padding:10px 12px;border:1px solid #d8dde8;font-weight:600;\">External `&lt;script src&gt;` JSON-LD<\/td>\n<td style=\"padding:10px 12px;border:1px solid #d8dde8;\">Sometimes, no guarantee<\/td>\n<td style=\"padding:10px 12px;border:1px solid #d8dde8;\">Rarely the right answer, mostly an anti-pattern<\/td>\n<td style=\"padding:10px 12px;border:1px solid #d8dde8;\">Googlebot may not fetch the file before indexing the page<\/td>\n<\/tr>\n<tr>\n<td style=\"padding:10px 12px;border:1px solid #d8dde8;font-weight:600;\">Inline microdata in body<\/td>\n<td style=\"padding:10px 12px;border:1px solid #d8dde8;\">Yes, parsed alongside visible DOM<\/td>\n<td style=\"padding:10px 12px;border:1px solid #d8dde8;\">Product detail pages, reviews, breadcrumb trails<\/td>\n<td style=\"padding:10px 12px;border:1px solid #d8dde8;\">Theme\/template edits can break attribute pairing silently<\/td>\n<\/tr>\n<tr style=\"background:#F8F9FC;\">\n<td style=\"padding:10px 12px;border:1px solid #d8dde8;font-weight:600;\">RDFa in body<\/td>\n<td style=\"padding:10px 12px;border:1px solid #d8dde8;\">Yes, but rarely seen in modern stacks<\/td>\n<td style=\"padding:10px 12px;border:1px solid #d8dde8;\">Legacy templates where rewriting to JSON-LD isn't feasible<\/td>\n<td style=\"padding:10px 12px;border:1px solid #d8dde8;\">Few developers know it well, so maintenance burden is high<\/td>\n<\/tr>\n<\/tbody>\n<\/table><figcaption style=\"text-align:center;color:#6a7280;font-size:.88em;margin-top:8px;\">Six common placement patterns mapped against how Google actually parses them. The first two are interchangeable, the rest carry real trade-offs.<\/figcaption><\/figure>\n<p>The pattern most teams should avoid is the third row, JavaScript-injected JSON-LD with no static fallback. Googlebot handles it, but it does so on the second rendering pass, and most other crawlers (including the LLM bots that increasingly drive entity recognition outside of search) read the raw HTML and move on. In my experience the moment you ship JS-injected schema is also the moment your structured data stops showing up in Bing Webmaster Tools. Sometimes within hours. Once shipped a Next.js client component that mounted Article schema in a useEffect, fixed it by moving the same block to getServerSideProps, Bing picked it up inside 48 hours.<\/p>\n<h2>Where to Place Schema by Entity Type<\/h2>\n<h3>Organization and WebSite schema<\/h3>\n<p>Place Organization and WebSite schema in the `<head>` of your homepage using JSON-LD. These top-level schemas anchor your site's identity in Google's Knowledge Graph, helping the search engine understand who you are as an entity rather than just a collection of pages. Include your logo, contact info, and social profile URLs in sameAs arrays to consolidate mentions across platforms.<\/p>\n<p>Why it matters: Google uses this data to populate Knowledge Panels and attribute other content back to your brand entity. For: SEO leads and developers building foundational semantic infrastructure. Deploy once per domain, duplication across pages dilutes signals. Validate with Google's Rich Results Test before pushing live to catch syntax errors that break entity recognition.<\/p>\n<div style=\"border-left:3px solid #4A90B8;background:#EEF5FA;padding:14px 18px;margin:24px 0;border-radius:0 4px 4px 0;\">\n<p style=\"margin:0 0 4px;font-size:.78em;font-weight:700;letter-spacing:.06em;text-transform:uppercase;color:#1F4A66;\">Note<\/p>\n<p style=\"margin:0;\">Your Organization schema only needs to appear once per domain, but it needs to appear on a page Google crawls frequently. The homepage is the canonical choice. Putting it in a sitewide template header is fine too, just make sure the `@id` is stable so every other page can reference it.<\/p>\n<\/div>\n<h3>Article and BlogPosting schema<\/h3>\n<p>Add Article and BlogPosting schema via JSON-LD in the `<head>` section or just before `<\/body>` on individual content pages. Both placements work. Head placement keeps all structured data consolidated for easier audits, while bottom-of-body keeps markup close to the rendered content.<\/p>\n<p>The critical detail: use `@id` references to connect articles to their <a href=\"https:\/\/hetneo.link\/blog\/why-google-now-treats-authors-like-entities-and-how-to-optimize-yours\/\">author entities<\/a> and publisher entities defined elsewhere. Instead of repeating full Person or Organization objects inside every article, reference them with `\"author\": {\"@id\": \"https:\/\/yoursite.com\/#\/schema\/person\/123\"}`. This signals to Google that the same entity appears across multiple pages, strengthening Knowledge Graph recognition and entity disambiguation. Define the full author and publisher schemas once in a sitewide or homepage JSON-LD block, then reference those definitions by `@id` in every article's markup to establish persistent entity relationships.<\/p>\n<h3>Product and Offer schema<\/h3>\n<p>JSON-LD inside the head element is the cleanest option for Product schema, it keeps structured data separate from your HTML and simplifies maintenance. Alternatively, wrap microdata attributes (`itemprop=\"name\"`, `itemprop=\"price\"`, `itemprop=\"availability\"`) directly around visible product details in the body. Both methods work, but your markup must mirror what users actually see: if the page shows $49.99 and \"In Stock,\" your schema must declare the same values. Mismatches trigger validation warnings in Search Console and block rich results. Include AggregateRating or Review markup only when real customer reviews appear on the page. Google's Merchant Center also ingests Product schema to generate Shopping Graph entities, so accurate, visible alignment is essential for both organic snippets and commercial recognition.<\/p>\n<h3>Breadcrumb schema<\/h3>\n<p>Breadcrumb schema mirrors your visible navigation trail, Home > Category > Page, using either JSON-LD in the head or microdata inline with the HTML nav element. Place it wherever your breadcrumb markup lives. JSON-LD offers cleaner separation, microdata keeps schema directly adjacent to user-facing content. Google uses breadcrumb schema to map your site's hierarchy and understand how entities nest within broader topics, strengthening Knowledge Graph connections for parent-child relationships. Mismatched breadcrumbs, where schema diverges from visible navigation, confuse crawlers and dilute entity signals. Deploy on every page with a breadcrumb trail, matching the exact structure users see, to reinforce categorical relationships that feed into entity recognition and sitelink generation in search results.<\/p>\n<h3>LocalBusiness and location entities<\/h3>\n<p>Place LocalBusiness schema in the `<head>` as JSON-LD on city or branch pages, or embed microdata directly in contact sections if your CMS limits header access. Either format works, but consistency matters for parser reliability. Include complete address markup with `streetAddress`, `addressLocality`, `addressRegion`, and `postalCode` properties, partial addresses won't trigger Knowledge Panels. Add geo coordinates (`latitude`, `longitude`) to strengthen map pack eligibility and `openingHoursSpecification` arrays with `dayOfWeek` and `opens`\/`closes` times for each operating period. Google's validator will flag missing properties that block local entity recognition. For multi-location businesses, implement separate schema instances per page rather than aggregating all branches in one markup block, since Knowledge Graph treats each physical location as a distinct entity requiring independent structured data.<\/p>\n<h3>FAQ and HowTo schema<\/h3>\n<p>FAQ schema can live in the head as JSON-LD or inline beside the visible questions. Both work, but JSON-LD centralizes maintenance and scales better across dynamic pages. Inline placement near the rendered FAQ lets crawlers confirm tight alignment between markup and user-facing content, reinforcing entity signals when questions target high-value keywords. Structure each Question and acceptedAnswer pair to mirror the wording on-page. Consistent terminology helps Google extract featured snippets and tie your page to Knowledge Graph entities. HowTo schema follows the same rules: JSON-LD for simplicity, or itemscope microdata wrapping each step if your CMS makes inline editing easier. Either way, validate that step order, images, and supply lists match what users see, schema that diverges from visible content risks being ignored or penalized.<\/p>\n<h2>The Placement Decision Tree<\/h2>\n<p>Here's the thing, the decision doesn't actually require six tools or a 40-line checklist. Probably not even four. The right placement falls out of three questions answered in order.<\/p>\n<div style=\"background:#FAFBFD;border:1px solid #d8dde8;border-radius:6px;padding:24px;margin:28px 0;\">\n<p style=\"margin:0 0 18px;font-weight:700;letter-spacing:.04em;text-transform:uppercase;font-size:.78em;color:#1F2A44;\">Placement decision workflow<\/p>\n<div style=\"display:flex;flex-wrap:wrap;gap:12px;\">\n<div style=\"flex:1 1 200px;background:#fff;border:1px solid #d8dde8;border-radius:4px;padding:14px;\">\n<div style=\"font-size:.78em;font-weight:700;color:#8A6A12;letter-spacing:.05em;\">STEP 1<\/div>\n<div style=\"font-weight:600;margin:6px 0 4px;\">Site-wide or page-specific?<\/div>\n<div style=\"font-size:.9em;color:#3a4458;\">Organization, WebSite, SearchAction \u2192 template head. Article, Product, Event \u2192 per-page head.<\/div>\n<\/div>\n<div style=\"flex:0 0 auto;align-self:center;font-size:1.5em;color:#1F2A44;\">\u2192<\/div>\n<div style=\"flex:1 1 200px;background:#fff;border:1px solid #d8dde8;border-radius:4px;padding:14px;\">\n<div style=\"font-size:.78em;font-weight:700;color:#8A6A12;letter-spacing:.05em;\">STEP 2<\/div>\n<div style=\"font-weight:600;margin:6px 0 4px;\">Does the schema describe visible content?<\/div>\n<div style=\"font-size:.9em;color:#3a4458;\">If yes (Product prices, BreadcrumbList, LocalBusiness address), inline microdata is a defensible choice.<\/div>\n<\/div>\n<div style=\"flex:0 0 auto;align-self:center;font-size:1.5em;color:#1F2A44;\">\u2192<\/div>\n<div style=\"flex:1 1 200px;background:#fff;border:1px solid #d8dde8;border-radius:4px;padding:14px;\">\n<div style=\"font-size:.78em;font-weight:700;color:#8A6A12;letter-spacing:.05em;\">STEP 3<\/div>\n<div style=\"font-weight:600;margin:6px 0 4px;\">Is the head injectable server-side?<\/div>\n<div style=\"font-size:.9em;color:#3a4458;\">If no, ship JSON-LD just before `&lt;\/body&gt;`. Avoid JS-injected JSON-LD when SSR is an option.<\/div>\n<\/div>\n<div style=\"flex:0 0 auto;align-self:center;font-size:1.5em;color:#1F2A44;\">\u2192<\/div>\n<div style=\"flex:1 1 200px;background:#fff;border:1px solid #d8dde8;border-radius:4px;padding:14px;\">\n<div style=\"font-size:.78em;font-weight:700;color:#8A6A12;letter-spacing:.05em;\">STEP 4<\/div>\n<div style=\"font-weight:600;margin:6px 0 4px;\">Validate<\/div>\n<div style=\"font-size:.9em;color:#3a4458;\">Rich Results Test the live URL, not the local file. Confirm Search Console picks up the entity within a week.<\/div>\n<\/div>\n<\/div>\n<\/div>\n<p>Look, the first question handles 80% of the decisions. Most teams over-think this because they assume there's a clever pattern hiding inside the trade-offs. There isn't. Site-wide schemas go in the template head once, page-specific schemas get injected dynamically into the per-page head, and inline microdata earns its keep only when the schema describes content the visible page already shows.<\/p>\n<h2>What Google Actually Crawls vs Renders<\/h2>\n<p>There's a layer underneath the placement question that matters more than most posts admit: Google has two passes, and your schema needs to survive both. The initial HTML crawl reads everything in the static response. The render pass, which happens later and on a separate queue, evaluates the JavaScript-executed DOM. Schema injected client-side only shows up in the render pass, which means there's a window (sometimes hours, more often days, occasionally weeks on lower-priority pages) where Google has indexed the page without your structured data.<\/p>\n<style>\n.hl-deepdive summary::-webkit-details-marker { display:none; }\n.hl-deepdive summary { outline:none; }\n.hl-deepdive[open] .hl-deepdive__icon { transform:rotate(180deg); background:#8A6A12; }\n.hl-deepdive[open] .hl-deepdive__eyebrow::after { content:\" \u00b7 click to collapse\"; }\n.hl-deepdive:not([open]) .hl-deepdive__eyebrow::after { content:\" \u00b7 click to expand\"; }\n.hl-deepdive:hover { box-shadow:0 4px 14px rgba(31,42,68,.12); transform:translateY(-1px); }\n.hl-deepdive { transition:box-shadow .2s ease, transform .2s ease; }\n.hl-deepdive__icon { transition:transform .25s ease, background .25s ease; }\n<\/style>\n<details class=\"hl-deepdive\" style=\"border:1px solid #d8dde8;border-radius:10px;margin:28px 0;background:linear-gradient(180deg,#FAFBFD 0%,#F1F4FA 100%);box-shadow:0 1px 4px rgba(31,42,68,.08);overflow:hidden;\">\n<summary style=\"cursor:pointer;padding:20px 24px;list-style:none;display:flex;align-items:center;gap:16px;\">\n<span class=\"hl-deepdive__icon\" style=\"flex:0 0 auto;display:inline-flex;align-items:center;justify-content:center;width:40px;height:40px;background:#1F2A44;color:#fff;border-radius:50%;font-size:1.4em;line-height:1;font-weight:700;\">\u25be<\/span><br \/>\n<span style=\"flex:1 1 auto;\"><br \/>\n<span class=\"hl-deepdive__eyebrow\" style=\"display:block;font-size:.72em;font-weight:700;letter-spacing:.1em;text-transform:uppercase;color:#8A6A12;\">Deep dive<\/span><br \/>\n<span style=\"display:block;font-size:1.08em;font-weight:700;color:#1F2A44;margin-top:3px;\">Crawl pass vs render pass, and where each parser actually looks<\/span><br \/>\n<\/span><br \/>\n<\/summary>\n<div style=\"padding:18px 24px 22px;color:#3a4458;border-top:1px solid #e3e8f0;background:#fff;\">\n<p>The two-pass model is worth understanding because it explains a lot of the \"my schema isn't showing up\" reports that don't show up in any validator:<\/p>\n<ol style=\"padding-left:22px;\">\n<li><strong>Crawl pass.<\/strong> Googlebot fetches the raw HTML and parses everything in the static response. JSON-LD in the head and inline microdata in the body are both visible on this pass. JS-injected schema is not.<\/li>\n<li><strong>Render pass.<\/strong> The page is queued for the Web Rendering Service, which executes JavaScript and re-parses the DOM. JS-injected JSON-LD is visible here, but the queue can lag, sometimes hours, sometimes days on lower-priority pages.<\/li>\n<li><strong>Index pass.<\/strong> The combined data (static crawl + rendered DOM) feeds the index and Knowledge Graph ingestion. Schema present in both passes is treated as authoritative. Schema present only in the render pass can show up later, or not at all, if rendering fails.<\/li>\n<li><strong>Other crawlers.<\/strong> Bingbot, Yandex, Applebot, and most LLM crawlers (GPTBot, ClaudeBot, PerplexityBot, etc.) read the static HTML and skip rendering entirely. Schema you only render client-side is invisible to them.<\/li>\n<li><strong>Validators.<\/strong> The Rich Results Test renders the page like Googlebot does, which is why JS-injected schema \"validates\" but still underperforms in production. Schema Markup Validator parses the raw response only, more honest, less forgiving.<\/li>\n<\/ol>\n<p>The practical takeaway: ship schema in the static HTML response wherever possible. Server-side render it, build it at deploy time, or output it via your CMS template, anything except inject it from a `useEffect` hook.<\/p>\n<\/div>\n<\/details>\n<p>That two-pass model is also why Ahrefs's <a href=\"https:\/\/ahrefs.com\/blog\/schema-markup\/\" rel=\"noopener\">schema documentation<\/a> reaches the same conclusion most experienced practitioners do: if you only ever do one thing right with structured data, ship it server-side. Placement choices matter, but they matter inside the static HTML response, not inside whatever your front-end framework renders on the second pass.<\/p>\n<figure class=\"wp-block-image size-large\">\n<img loading=\"lazy\" decoding=\"async\" width=\"900\" height=\"514\" src=\"https:\/\/hetneo.link\/blog\/wp-content\/uploads\/2026\/01\/entity-linking-relationships.jpg\" alt=\"Interconnected filing system representing entity relationships and data structure\" class=\"wp-image-377\" srcset=\"https:\/\/hetneo.link\/blog\/wp-content\/uploads\/2026\/01\/entity-linking-relationships.jpg 900w, https:\/\/hetneo.link\/blog\/wp-content\/uploads\/2026\/01\/entity-linking-relationships-300x171.jpg 300w, https:\/\/hetneo.link\/blog\/wp-content\/uploads\/2026\/01\/entity-linking-relationships-768x439.jpg 768w\" sizes=\"auto, (max-width: 900px) 100vw, 900px\" \/><figcaption>Entity linking through @id properties creates clear relationships between different pieces of structured data, similar to how organized systems connect related information.<\/figcaption><\/figure>\n<h2>Entity Linking Best Practices<\/h2>\n<h3>Using @id to create entity URIs<\/h3>\n<p>Google treats entities like your company, authors, or flagship products as nodes in its Knowledge Graph. Without stable identifiers, mentions across pages remain disconnected. The `@id` property solves this by assigning each entity a permanent URI, typically your canonical page URL plus a fragment anchor.<\/p>\n<p>For your organization, use `https:\/\/yoursite.com\/#organization` in every Organization schema block across your site. Author pages get `https:\/\/yoursite.com\/about\/jane-doe\/#person`. Local branches need distinct IDs like `https:\/\/yoursite.com\/locations\/boston\/#location`.<\/p>\n<p>Place these in JSON-LD within the head or body, location doesn't matter as long as you're consistent. When a product appears on category pages, its detail page, and a blog post, the same `@id` tells Google they're one entity, not three. This consolidation strengthens your Knowledge Graph presence and improves how Google surfaces your brand in search features.<\/p>\n<p>Why it matters: fragmented entity mentions dilute authority. Unified IDs compound it across every page where you're mentioned.<\/p>\n<p>For: SEO practitioners managing multi-page sites, developers implementing schema at scale, content teams coordinating author or product references.<\/p>\n<h3>Nesting and referencing related entities<\/h3>\n<p>Search engines connect entities by following nested properties and references within your schema. When you embed a Person type inside the author property of an Article, you're declaring an entity relationship that powers <a href=\"https:\/\/hetneo.link\/blog\/information-gain-and-entity-salience-the-on-page-signals-search-engines-actually-read\/\">Knowledge Graph recognition<\/a> and disambiguation. Place these nested structures within the same JSON-LD block to maintain context: a Product should contain a nested Brand object with at least a name property, while a LocalBusiness can reference its parent Organization using the parentOrganization property. Use `@id` values to link entities across separate JSON-LD blocks when nesting becomes unwieldy, for example, define your Organization once with an `@id` of \"#organization\", then reference it elsewhere with `\"publisher\": {\"@id\": \"#organization\"}`. This creates an internal entity graph that mirrors how search engines model relationships, helping them understand which John Smith authored your article and which Main Street Bakery you're describing.<\/p>\n<h2>Common Placement Mistakes That Break Entity Recognition<\/h2>\n<p>Misplaced or malformed schema breaks the connection between your page and Google's Knowledge Graph, even when validation tools pass. Even when the green checkmark says you're fine. The most common mistake: visible content doesn't match schema declarations. If your markup claims an author named \"Dr. Sarah Chen\" but the byline shows \"S. Chen,\" entity resolution fails, Google won't connect your page to the real-world entity.<\/p>\n<p>Duplicate schemas for the same entity confuse crawlers. Inserting both a JSON-LD Person block in the head and microdata inline around the author bio sends conflicting signals. Choose one format per entity and place it once. JSON-LD in the head keeps it cleanest.<\/p>\n<div style=\"border-left:3px solid #4A90B8;background:#EEF5FA;padding:14px 18px;margin:24px 0;border-radius:0 4px 4px 0;\">\n<p style=\"margin:0 0 4px;font-size:.78em;font-weight:700;letter-spacing:.06em;text-transform:uppercase;color:#1F4A66;\">Watch for<\/p>\n<p style=\"margin:0;\">Splitting one entity's properties across two `<script type=\"application\/ld+json\">` blocks is the #1 placement bug I see on audits. Two scripts produce two separate parses. Google does not merge them into a single entity. Consolidate each discrete entity into one complete JSON-LD object inside one script tag.<\/p>\n<\/div>\n<p>Missing `sameAs` links prevent Knowledge Graph alignment. Schema without references to authoritative profiles, Wikipedia, Wikidata, official brand URLs, leaves Google guessing which real-world entity you mean. Always include `sameAs` properties pointing to external entity identifiers, especially for Organization and Person types.<\/p>\n<p>Validation tools check syntax but miss semantic errors. A page might validate perfectly while listing `@type: MedicalWebPage` without meeting Google's E-E-A-T requirements or lacking the medical reviewer markup Google expects. Test not just for errors but for complete entity graphs, does your schema answer \"who wrote this,\" \"who published it,\" and \"what organization do they represent\" with linked, verifiable entities?<\/p>\n<p>Placement matters for processing order. Put foundational entities like Organization and WebSite in the head before article-level schema. Nested entities, a Recipe inside an Article, must share the same parent scope. Scattered fragments across head and body often fail to merge into a coherent entity graph.<\/p>\n<h2>Testing and Validating Your Placement<\/h2>\n<p>After adding your schema markup, confirm it's readable and error-free using <a href=\"https:\/\/search.google.com\/test\/rich-results\" rel=\"noopener\">Google's Rich Results Test<\/a>, paste your URL or raw code to see which structured data types are detected and whether they're eligible for enhanced search features. For broader validation across all schema types, use the <a href=\"https:\/\/validator.schema.org\/\" rel=\"noopener\">Schema Markup Validator<\/a>, which flags syntax errors, missing required properties, and mismatched entity relationships that could block Knowledge Graph indexing.<\/p>\n<figure class=\"wp-block-image size-large\">\n<img decoding=\"async\" src=\"https:\/\/hetneo.link\/blog\/wp-content\/uploads\/2026\/05\/rich-results-test.png\" alt=\"Google's Rich Results Test interface showing a URL input field and the structured data types detected on a tested page\"\/><figcaption>The Rich Results Test renders the page like Googlebot does, which means it surfaces both head-placed and JS-injected JSON-LD. Useful for confirming the schema is parseable, less useful for confirming it survives every crawler's first pass.<\/figcaption><\/figure>\n<p>Why validation matters: placement errors, like JSON-LD blocks loading after critical DOM rendering or microdata nested incorrectly, often pass silently but fail to register with crawlers.<\/p>\n<p>Next, monitor Search Console's Enhancements report for entity-specific warnings: unparsable dates on Event schemas, missing aggregateRating properties on Product markup, or author\/publisher mismatches on Article entities. These reports surface real-world crawl issues that testing tools may miss, especially for dynamically injected markup. Screamingfrog's <a href=\"https:\/\/www.screamingfrog.co.uk\/seo-spider\/tutorials\/how-to-test-validate-schema-com-structured-data\/\" rel=\"noopener\">schema validation guide<\/a> walks through bulk-checking across a crawl, which is faster than one-by-one validation when you're shipping schema across hundreds of templates.<\/p>\n<p>For: SEOs and developers who need to confirm their placement strategy actually delivers the intended search visibility, not just technically valid code.<\/p>\n<figure class=\"wp-block-image size-large\">\n<img loading=\"lazy\" decoding=\"async\" width=\"900\" height=\"514\" src=\"https:\/\/hetneo.link\/blog\/wp-content\/uploads\/2026\/01\/schema-validation-testing.jpg\" alt=\"Hands using magnifying glass to examine and validate webpage structure for errors\" class=\"wp-image-378\" srcset=\"https:\/\/hetneo.link\/blog\/wp-content\/uploads\/2026\/01\/schema-validation-testing.jpg 900w, https:\/\/hetneo.link\/blog\/wp-content\/uploads\/2026\/01\/schema-validation-testing-300x171.jpg 300w, https:\/\/hetneo.link\/blog\/wp-content\/uploads\/2026\/01\/schema-validation-testing-768x439.jpg 768w\" sizes=\"auto, (max-width: 900px) 100vw, 900px\" \/><figcaption>Testing and validating schema markup placement ensures proper entity recognition and prevents technical errors that break Knowledge Graph alignment.<\/figcaption><\/figure>\n<h2>Head Placement vs Body Placement: When Each Wins<\/h2>\n<p>Both placements are valid, but they earn their keep in different contexts. Anyway, the two-card view below collapses the long version of this argument into something you can act on without re-reading the post.<\/p>\n<div style=\"display:flex;flex-wrap:wrap;gap:16px;margin:28px 0;\">\n<div style=\"flex:1 1 280px;background:#EEF7EF;border:1px solid #BFE0C5;border-radius:8px;padding:20px 22px;\">\n<p style=\"margin:0 0 14px;font-weight:700;color:#2D6A36;font-size:.95em;display:flex;align-items:center;gap:10px;\">\n<span style=\"display:inline-flex;align-items:center;justify-content:center;width:26px;height:26px;background:#2D6A36;color:#fff;border-radius:50%;font-size:.9em;line-height:1;\">\u2713<\/span><br \/>\nPick head placement for\n<\/p>\n<ul style=\"margin:0;padding-left:0;list-style:none;display:grid;gap:8px;\">\n<li style=\"display:flex;gap:10px;\"><span style=\"color:#2D6A36;font-weight:700;flex:0 0 auto;\">\u203a<\/span>Site-wide entities (Organization, WebSite, SearchAction)<\/li>\n<li style=\"display:flex;gap:10px;\"><span style=\"color:#2D6A36;font-weight:700;flex:0 0 auto;\">\u203a<\/span>Article and BlogPosting on content-heavy templates<\/li>\n<li style=\"display:flex;gap:10px;\"><span style=\"color:#2D6A36;font-weight:700;flex:0 0 auto;\">\u203a<\/span>Product schema where price and stock are CMS-driven<\/li>\n<li style=\"display:flex;gap:10px;\"><span style=\"color:#2D6A36;font-weight:700;flex:0 0 auto;\">\u203a<\/span>Pages that need consolidated auditing in a single JSON-LD block<\/li>\n<li style=\"display:flex;gap:10px;\"><span style=\"color:#2D6A36;font-weight:700;flex:0 0 auto;\">\u203a<\/span>Any schema you want non-Google crawlers to see on first pass<\/li>\n<\/ul>\n<\/div>\n<div style=\"flex:1 1 280px;background:#F5F5F7;border:1px solid #d8dde8;border-radius:8px;padding:20px 22px;\">\n<p style=\"margin:0 0 14px;font-weight:700;color:#6a7280;font-size:.95em;display:flex;align-items:center;gap:10px;\">\n<span style=\"display:inline-flex;align-items:center;justify-content:center;width:26px;height:26px;background:#9aa3b2;color:#fff;border-radius:50%;font-size:.9em;line-height:1;\">\u2717<\/span><br \/>\nPick body or inline placement for\n<\/p>\n<ul style=\"margin:0;padding-left:0;list-style:none;display:grid;gap:8px;color:#6a7280;\">\n<li style=\"display:flex;gap:10px;\"><span style=\"color:#9aa3b2;font-weight:700;flex:0 0 auto;\">\u203a<\/span>BreadcrumbList tied to a visible nav element<\/li>\n<li style=\"display:flex;gap:10px;\"><span style=\"color:#9aa3b2;font-weight:700;flex:0 0 auto;\">\u203a<\/span>LocalBusiness on contact pages where the address is editable inline<\/li>\n<li style=\"display:flex;gap:10px;\"><span style=\"color:#9aa3b2;font-weight:700;flex:0 0 auto;\">\u203a<\/span>Legacy CMSes that lock down the head template<\/li>\n<li style=\"display:flex;gap:10px;\"><span style=\"color:#9aa3b2;font-weight:700;flex:0 0 auto;\">\u203a<\/span>Review\/Rating markup welded to user-generated content blocks<\/li>\n<li style=\"display:flex;gap:10px;\"><span style=\"color:#9aa3b2;font-weight:700;flex:0 0 auto;\">\u203a<\/span>Cases where the editorial team would otherwise break the schema<\/li>\n<\/ul>\n<\/div>\n<\/div>\n<p>Truth is, the head\/body question is less interesting than the static\/rendered question. A `<script>` block in the body, server-rendered, beats a `<script>` block in the head that's injected client-side, every time. Get the static delivery right first, then optimize for placement.<\/p>\n<h2>Putting Schema Placement to Work<\/h2>\n<p>Schema placement is one of those technical SEO decisions that looks like a paint-by-numbers exercise until you ship it on a real site and watch the Knowledge Graph ignore half your entities. The discipline is mostly about restraint. One entity per script block, one stable `@id` per entity, one source of truth for site-wide schemas. Get those three rules right and the head-vs-body debate basically stops mattering on most templates.<\/p>\n<p>For most teams the rollout looks like: Organization and WebSite in the template head, Article\/Product\/Event injected per-page, BreadcrumbList alongside the visible nav (head JSON-LD is fine, body microdata if your stack already has it), LocalBusiness in the head of every branch page. Validate with Rich Results Test on the live URL, then watch Search Console for Enhancements warnings over the next week or two. That cadence catches the placement bugs that static validators miss.<\/p>\n<div style=\"background:linear-gradient(135deg,#1F2A44 0%,#2B3A5C 100%);color:#fff;border-radius:10px;padding:30px 32px;margin:36px 0;box-shadow:0 4px 14px rgba(31,42,68,.18);\">\n<p style=\"margin:0 0 6px;font-size:.78em;font-weight:700;letter-spacing:.12em;text-transform:uppercase;color:#F1D481;\">Try it this week<\/p>\n<p style=\"margin:0 0 22px;font-size:1.32em;font-weight:700;line-height:1.3;color:#fff;\">Audit three templates. Confirm every schema renders server-side, in the head, with a stable @id.<\/p>\n<ol style=\"margin:0;padding-left:0;list-style:none;display:grid;gap:14px;\">\n<li style=\"display:flex;gap:14px;align-items:flex-start;\">\n<span style=\"flex:0 0 auto;display:inline-flex;align-items:center;justify-content:center;width:28px;height:28px;background:rgba(241,212,129,.18);color:#F1D481;border:1px solid rgba(241,212,129,.4);border-radius:50%;font-weight:700;font-size:.9em;line-height:1;\">1<\/span><br \/>\n<span style=\"color:rgba(255,255,255,.92);\">Pick three high-value templates: homepage, a content article, a product or contact page. View source on each, not the rendered DOM, and confirm JSON-LD appears in the raw HTML.<\/span>\n<\/li>\n<li style=\"display:flex;gap:14px;align-items:flex-start;\">\n<span style=\"flex:0 0 auto;display:inline-flex;align-items:center;justify-content:center;width:28px;height:28px;background:rgba(241,212,129,.18);color:#F1D481;border:1px solid rgba(241,212,129,.4);border-radius:50%;font-weight:700;font-size:.9em;line-height:1;\">2<\/span><br \/>\n<span style=\"color:rgba(255,255,255,.92);\">Run each URL through Rich Results Test and Schema Markup Validator. Note any entity that splits across two `<script>` blocks, that's the bug to fix first.<\/span>\n<\/li>\n<li style=\"display:flex;gap:14px;align-items:flex-start;\">\n<span style=\"flex:0 0 auto;display:inline-flex;align-items:center;justify-content:center;width:28px;height:28px;background:rgba(241,212,129,.18);color:#F1D481;border:1px solid rgba(241,212,129,.4);border-radius:50%;font-weight:700;font-size:.9em;line-height:1;\">3<\/span><br \/>\n<span style=\"color:rgba(255,255,255,.92);\">Document the `@id` for every site-wide entity. Anything missing a stable identifier gets one before next week's deploy, that's the cheapest Knowledge Graph win on the board.<\/span>\n<\/li>\n<\/ol>\n<p style=\"margin:22px 0 0;font-size:.92em;color:rgba(255,255,255,.7);font-style:italic;\">Placement is the part of schema work most teams treat as cosmetic. It isn't, it's the difference between Google indexing an entity once and indexing it three contradictory ways.<\/p>\n<\/div>\n<h2>Related guides<\/h2>\n<ul>\n<li><a href=\"https:\/\/hetneo.link\/blog\/why-google-now-treats-authors-like-entities-and-how-to-optimize-yours\/\"><strong>Authors as Entities<\/strong><\/a>, How `@id` references turn bylines into Knowledge Graph nodes Google can actually disambiguate.<\/li>\n<li><a href=\"https:\/\/hetneo.link\/blog\/information-gain-and-entity-salience-the-on-page-signals-search-engines-actually-read\/\"><strong>Entity Salience Signals<\/strong><\/a>, The on-page signals that determine which entities Google attributes to your content.<\/li>\n<\/ul>\n","protected":false},"excerpt":{"rendered":"<p>Schema markup belongs in the &#8220; as JSON-LD, that&#8217;s the short answer Google has given us for years. The longer&#8230;<\/p>\n","protected":false},"author":4,"featured_media":375,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[4],"tags":[],"class_list":["post-379","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-on-page-content"],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v27.6 - https:\/\/yoast.com\/product\/yoast-seo-wordpress\/ -->\n<title>Where Schema Markup Actually Goes (And Why It Matters)<\/title>\n<meta name=\"description\" content=\"Schema markup placement matters more than format. Why JSON-LD in beats inline microdata, and which schemas belong on every page vs. specific ones.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/hetneo.link\/blog\/where-schema-markup-actually-goes-and-why-placement-matters-for-entity-recognition\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Where Schema Markup Actually Goes (And Why It Matters)\" \/>\n<meta property=\"og:description\" content=\"Schema markup placement matters more than format. Why JSON-LD in beats inline microdata, and which schemas belong on every page vs. specific ones.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/hetneo.link\/blog\/where-schema-markup-actually-goes-and-why-placement-matters-for-entity-recognition\/\" \/>\n<meta property=\"og:site_name\" content=\"Hetneo&#039;s Links Blog\" \/>\n<meta property=\"article:published_time\" content=\"2026-01-26T09:01:32+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2026-05-16T04:17:22+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/hetneo.link\/blog\/wp-content\/uploads\/2026\/01\/schema-markup-code-placement.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"900\" \/>\n\t<meta property=\"og:image:height\" content=\"514\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"madison\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@maddiehoulding\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"madison\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"21 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/hetneo.link\\\/blog\\\/where-schema-markup-actually-goes-and-why-placement-matters-for-entity-recognition\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/hetneo.link\\\/blog\\\/where-schema-markup-actually-goes-and-why-placement-matters-for-entity-recognition\\\/\"},\"author\":{\"name\":\"madison\",\"@id\":\"https:\\\/\\\/hetneo.link\\\/blog\\\/#\\\/schema\\\/person\\\/6c6a683e9a50d03ee7fa5ac6432d56a6\"},\"headline\":\"Where Schema Markup Actually Goes (And Why Placement Matters for Entity Recognition)\",\"datePublished\":\"2026-01-26T09:01:32+00:00\",\"dateModified\":\"2026-05-16T04:17:22+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/hetneo.link\\\/blog\\\/where-schema-markup-actually-goes-and-why-placement-matters-for-entity-recognition\\\/\"},\"wordCount\":4152,\"commentCount\":0,\"image\":{\"@id\":\"https:\\\/\\\/hetneo.link\\\/blog\\\/where-schema-markup-actually-goes-and-why-placement-matters-for-entity-recognition\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/hetneo.link\\\/blog\\\/wp-content\\\/uploads\\\/2026\\\/01\\\/schema-markup-placement-json-ld-laptop-hero.jpeg\",\"articleSection\":[\"On-Page &amp; Content\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/hetneo.link\\\/blog\\\/where-schema-markup-actually-goes-and-why-placement-matters-for-entity-recognition\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/hetneo.link\\\/blog\\\/where-schema-markup-actually-goes-and-why-placement-matters-for-entity-recognition\\\/\",\"url\":\"https:\\\/\\\/hetneo.link\\\/blog\\\/where-schema-markup-actually-goes-and-why-placement-matters-for-entity-recognition\\\/\",\"name\":\"Where Schema Markup Actually Goes (And Why It Matters)\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/hetneo.link\\\/blog\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/hetneo.link\\\/blog\\\/where-schema-markup-actually-goes-and-why-placement-matters-for-entity-recognition\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/hetneo.link\\\/blog\\\/where-schema-markup-actually-goes-and-why-placement-matters-for-entity-recognition\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/hetneo.link\\\/blog\\\/wp-content\\\/uploads\\\/2026\\\/01\\\/schema-markup-placement-json-ld-laptop-hero.jpeg\",\"datePublished\":\"2026-01-26T09:01:32+00:00\",\"dateModified\":\"2026-05-16T04:17:22+00:00\",\"author\":{\"@id\":\"https:\\\/\\\/hetneo.link\\\/blog\\\/#\\\/schema\\\/person\\\/6c6a683e9a50d03ee7fa5ac6432d56a6\"},\"description\":\"Schema markup placement matters more than format. Why JSON-LD in beats inline microdata, and which schemas belong on every page vs. specific ones.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/hetneo.link\\\/blog\\\/where-schema-markup-actually-goes-and-why-placement-matters-for-entity-recognition\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/hetneo.link\\\/blog\\\/where-schema-markup-actually-goes-and-why-placement-matters-for-entity-recognition\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/hetneo.link\\\/blog\\\/where-schema-markup-actually-goes-and-why-placement-matters-for-entity-recognition\\\/#primaryimage\",\"url\":\"https:\\\/\\\/hetneo.link\\\/blog\\\/wp-content\\\/uploads\\\/2026\\\/01\\\/schema-markup-placement-json-ld-laptop-hero.jpeg\",\"contentUrl\":\"https:\\\/\\\/hetneo.link\\\/blog\\\/wp-content\\\/uploads\\\/2026\\\/01\\\/schema-markup-placement-json-ld-laptop-hero.jpeg\",\"width\":900,\"height\":514,\"caption\":\"Laptop on a modern desk showing a blurred HTML page with abstract JSON-LD blocks and subtly highlighted head and body sections, with a monitor and coffee mug softly blurred in the background.\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/hetneo.link\\\/blog\\\/where-schema-markup-actually-goes-and-why-placement-matters-for-entity-recognition\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/hetneo.link\\\/blog\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Where Schema Markup Actually Goes (And Why Placement Matters for Entity Recognition)\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/hetneo.link\\\/blog\\\/#website\",\"url\":\"https:\\\/\\\/hetneo.link\\\/blog\\\/\",\"name\":\"Hetneo's Links Blog\",\"description\":\"\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/hetneo.link\\\/blog\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/hetneo.link\\\/blog\\\/#\\\/schema\\\/person\\\/6c6a683e9a50d03ee7fa5ac6432d56a6\",\"name\":\"madison\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/f4d2520c34ef92cc2328426bfca387d318cbd9a2eec2d15835a67cc4a3414cd7?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/f4d2520c34ef92cc2328426bfca387d318cbd9a2eec2d15835a67cc4a3414cd7?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/f4d2520c34ef92cc2328426bfca387d318cbd9a2eec2d15835a67cc4a3414cd7?s=96&d=mm&r=g\",\"caption\":\"madison\"},\"description\":\"Content Manager at Hetneo's Links. Madison runs editorial across the link-building space, auditing campaigns, writing the briefs that keep guest posts from sounding like ad copy, and turning analytics into next month's roadmap. Loves a clean brief, hates a buried lede.\",\"sameAs\":[\"https:\\\/\\\/www.linkedin.com\\\/in\\\/madisonhoulding\\\/\",\"https:\\\/\\\/x.com\\\/maddiehoulding\"],\"url\":\"https:\\\/\\\/hetneo.link\\\/blog\\\/author\\\/madison\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Where Schema Markup Actually Goes (And Why It Matters)","description":"Schema markup placement matters more than format. Why JSON-LD in beats inline microdata, and which schemas belong on every page vs. specific ones.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/hetneo.link\/blog\/where-schema-markup-actually-goes-and-why-placement-matters-for-entity-recognition\/","og_locale":"en_US","og_type":"article","og_title":"Where Schema Markup Actually Goes (And Why It Matters)","og_description":"Schema markup placement matters more than format. Why JSON-LD in beats inline microdata, and which schemas belong on every page vs. specific ones.","og_url":"https:\/\/hetneo.link\/blog\/where-schema-markup-actually-goes-and-why-placement-matters-for-entity-recognition\/","og_site_name":"Hetneo&#039;s Links Blog","article_published_time":"2026-01-26T09:01:32+00:00","article_modified_time":"2026-05-16T04:17:22+00:00","og_image":[{"width":900,"height":514,"url":"https:\/\/hetneo.link\/blog\/wp-content\/uploads\/2026\/01\/schema-markup-code-placement.jpg","type":"image\/jpeg"}],"author":"madison","twitter_card":"summary_large_image","twitter_creator":"@maddiehoulding","twitter_misc":{"Written by":"madison","Est. reading time":"21 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/hetneo.link\/blog\/where-schema-markup-actually-goes-and-why-placement-matters-for-entity-recognition\/#article","isPartOf":{"@id":"https:\/\/hetneo.link\/blog\/where-schema-markup-actually-goes-and-why-placement-matters-for-entity-recognition\/"},"author":{"name":"madison","@id":"https:\/\/hetneo.link\/blog\/#\/schema\/person\/6c6a683e9a50d03ee7fa5ac6432d56a6"},"headline":"Where Schema Markup Actually Goes (And Why Placement Matters for Entity Recognition)","datePublished":"2026-01-26T09:01:32+00:00","dateModified":"2026-05-16T04:17:22+00:00","mainEntityOfPage":{"@id":"https:\/\/hetneo.link\/blog\/where-schema-markup-actually-goes-and-why-placement-matters-for-entity-recognition\/"},"wordCount":4152,"commentCount":0,"image":{"@id":"https:\/\/hetneo.link\/blog\/where-schema-markup-actually-goes-and-why-placement-matters-for-entity-recognition\/#primaryimage"},"thumbnailUrl":"https:\/\/hetneo.link\/blog\/wp-content\/uploads\/2026\/01\/schema-markup-placement-json-ld-laptop-hero.jpeg","articleSection":["On-Page &amp; Content"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/hetneo.link\/blog\/where-schema-markup-actually-goes-and-why-placement-matters-for-entity-recognition\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/hetneo.link\/blog\/where-schema-markup-actually-goes-and-why-placement-matters-for-entity-recognition\/","url":"https:\/\/hetneo.link\/blog\/where-schema-markup-actually-goes-and-why-placement-matters-for-entity-recognition\/","name":"Where Schema Markup Actually Goes (And Why It Matters)","isPartOf":{"@id":"https:\/\/hetneo.link\/blog\/#website"},"primaryImageOfPage":{"@id":"https:\/\/hetneo.link\/blog\/where-schema-markup-actually-goes-and-why-placement-matters-for-entity-recognition\/#primaryimage"},"image":{"@id":"https:\/\/hetneo.link\/blog\/where-schema-markup-actually-goes-and-why-placement-matters-for-entity-recognition\/#primaryimage"},"thumbnailUrl":"https:\/\/hetneo.link\/blog\/wp-content\/uploads\/2026\/01\/schema-markup-placement-json-ld-laptop-hero.jpeg","datePublished":"2026-01-26T09:01:32+00:00","dateModified":"2026-05-16T04:17:22+00:00","author":{"@id":"https:\/\/hetneo.link\/blog\/#\/schema\/person\/6c6a683e9a50d03ee7fa5ac6432d56a6"},"description":"Schema markup placement matters more than format. Why JSON-LD in beats inline microdata, and which schemas belong on every page vs. specific ones.","breadcrumb":{"@id":"https:\/\/hetneo.link\/blog\/where-schema-markup-actually-goes-and-why-placement-matters-for-entity-recognition\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/hetneo.link\/blog\/where-schema-markup-actually-goes-and-why-placement-matters-for-entity-recognition\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/hetneo.link\/blog\/where-schema-markup-actually-goes-and-why-placement-matters-for-entity-recognition\/#primaryimage","url":"https:\/\/hetneo.link\/blog\/wp-content\/uploads\/2026\/01\/schema-markup-placement-json-ld-laptop-hero.jpeg","contentUrl":"https:\/\/hetneo.link\/blog\/wp-content\/uploads\/2026\/01\/schema-markup-placement-json-ld-laptop-hero.jpeg","width":900,"height":514,"caption":"Laptop on a modern desk showing a blurred HTML page with abstract JSON-LD blocks and subtly highlighted head and body sections, with a monitor and coffee mug softly blurred in the background."},{"@type":"BreadcrumbList","@id":"https:\/\/hetneo.link\/blog\/where-schema-markup-actually-goes-and-why-placement-matters-for-entity-recognition\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/hetneo.link\/blog\/"},{"@type":"ListItem","position":2,"name":"Where Schema Markup Actually Goes (And Why Placement Matters for Entity Recognition)"}]},{"@type":"WebSite","@id":"https:\/\/hetneo.link\/blog\/#website","url":"https:\/\/hetneo.link\/blog\/","name":"Hetneo's Links Blog","description":"","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/hetneo.link\/blog\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/hetneo.link\/blog\/#\/schema\/person\/6c6a683e9a50d03ee7fa5ac6432d56a6","name":"madison","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/secure.gravatar.com\/avatar\/f4d2520c34ef92cc2328426bfca387d318cbd9a2eec2d15835a67cc4a3414cd7?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/f4d2520c34ef92cc2328426bfca387d318cbd9a2eec2d15835a67cc4a3414cd7?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/f4d2520c34ef92cc2328426bfca387d318cbd9a2eec2d15835a67cc4a3414cd7?s=96&d=mm&r=g","caption":"madison"},"description":"Content Manager at Hetneo's Links. Madison runs editorial across the link-building space, auditing campaigns, writing the briefs that keep guest posts from sounding like ad copy, and turning analytics into next month's roadmap. Loves a clean brief, hates a buried lede.","sameAs":["https:\/\/www.linkedin.com\/in\/madisonhoulding\/","https:\/\/x.com\/maddiehoulding"],"url":"https:\/\/hetneo.link\/blog\/author\/madison\/"}]}},"_links":{"self":[{"href":"https:\/\/hetneo.link\/blog\/wp-json\/wp\/v2\/posts\/379","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/hetneo.link\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/hetneo.link\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/hetneo.link\/blog\/wp-json\/wp\/v2\/users\/4"}],"replies":[{"embeddable":true,"href":"https:\/\/hetneo.link\/blog\/wp-json\/wp\/v2\/comments?post=379"}],"version-history":[{"count":0,"href":"https:\/\/hetneo.link\/blog\/wp-json\/wp\/v2\/posts\/379\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/hetneo.link\/blog\/wp-json\/wp\/v2\/media\/375"}],"wp:attachment":[{"href":"https:\/\/hetneo.link\/blog\/wp-json\/wp\/v2\/media?parent=379"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/hetneo.link\/blog\/wp-json\/wp\/v2\/categories?post=379"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/hetneo.link\/blog\/wp-json\/wp\/v2\/tags?post=379"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}