When structured data is not detected, the cause is usually one of seven mechanical errors: the script tag is wrong, the JSON does not parse, a security policy blocks the script, the markup only exists after a script runs, two blocks contradict each other, the @context is wrong, or a date is ambiguous. None of these need a schema expert. Each one can be found with a browser, curl, or Google's testing tools.

SymptomLikely causeFastest check
No structured data found at allWrong type on the script tag, or the page is blockedView source, search for application/ld+json
Parse error in a test toolInvalid JSONRun the block through jq
Present in the browser, missing in the testInjected late, or blocked by CSPCompare raw source with rendered HTML; check the console
Types recognized but values ignored or oddWrong @context, misspelled @type, ambiguous datesRead the block against the schema.org type
Two Organization or Article entities with different dataDuplicate blocks from a theme, a plugin and an appCount the blocks

1. Script type typos

Google documents JSON-LD as a <script type="application/ld+json"> tag, placed in either the <head> or the <body> [1]. A parser looking for that exact type will skip anything else.

Variants that show up in real templates:

<!-- Wrong -->
<script type="application/json+ld">
<script type="application/ld-json">
<script type="text/javascript">
<script>
<script type=”application/ld+json”>   <!-- curly quotes pasted from a doc editor -->

<!-- Right -->
<script type="application/ld+json">

How to spot it: fetch the raw HTML and list every script type.

curl -s https://example.com/page | grep -o '<script[^>]*>' | sort | uniq -c

If no line reads type="application/ld+json" exactly, you have found it. Placement in head or body is not the problem [1].

2. Invalid JSON

A block that does not parse is read as nothing. The usual causes:

  • A trailing comma after the last property.
  • Curly quotes or a stray character from a copy and paste.
  • An unescaped double quote or a raw line break inside a string, often from a product description or a CMS field.
  • Template placeholders left in, such as {{ price }} or undefined.
  • A </script> inside a string value, which closes the tag early. Escape it as <\/script>.
// Before: two errors
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "12" Desk Fan",
  "offers": { "@type": "Offer", "price": "29.00", },
}

// After
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "12\" Desk Fan",
  "offers": { "@type": "Offer", "price": "29.00" }
}

How to spot it: this script pulls every JSON-LD block from a URL and tries to parse it. It reads the raw HTML only.

import json, re, sys, urllib.request

html = urllib.request.urlopen(sys.argv[1]).read().decode("utf-8", "replace")
pat = r'<script[^>]*type=["\']application/ld\+json["\'][^>]*>(.*?)</script>'
blocks = re.findall(pat, html, re.S | re.I)
print(len(blocks), "block(s)")
for i, b in enumerate(blocks, 1):
    try:
        json.loads(b)
        print(i, "parses")
    except json.JSONDecodeError as e:
        print(i, "INVALID:", e)

Run it as python check.py https://example.com/page. The error message gives a line and column.

3. Blocked by a Content Security Policy

script-src controls which JavaScript sources a page may use, and inline script execution is blocked unless the policy allows it, for example through nonces or hashes [5]. If your JSON-LD is printed inline, or added by a tag manager, the policy is worth checking.

How to spot it:

  1. Open the page with DevTools and the Console tab.
  2. Look for a message saying a script was refused because of the Content Security Policy.
  3. Check whether it names your JSON-LD block or the tag manager script that creates it.
  4. Read the Content-Security-Policy header: curl -sI https://example.com/page | grep -i content-security-policy

If your block is named, allow it with a nonce or hash, which are the mechanisms MDN lists [5]. If a tag manager injects the markup, its source must be permitted in script-src [5].

If the console is clean, CSP is not your problem. Move on.

4. Markup that only exists after JavaScript runs

Google says it can read JSON-LD injected by JavaScript, provided the structured data is present in the rendered HTML [2]. It also notes that rendering has limits, and content not visible in the rendered HTML cannot be indexed [2]. A script that fails, times out or waits for a user action leaves you with no markup.

How to spot it:

  • Compare the raw source (curl, or View Source) with the rendered DOM (DevTools Elements tab). If the block appears only in the second, it is injected.
  • Run the URL through the URL Inspection Tool or the Rich Results Test and read the rendered HTML [3]. If the block is missing there, the injection is failing for Google too.

The most reliable fix is to print the block in the server-rendered HTML. If you must inject it, confirm it appears in the rendered HTML Google reports [2][3].

5. Duplicate and conflicting blocks

Themes, SEO plugins and apps each add their own JSON-LD. The result is often two Organization blocks with different names, logos or URLs, or two Article blocks with different dates. Google's documentation in the notes does not say how it resolves such conflicts, so remove them instead of relying on a tiebreak.

How to spot it: run the script from section 2 and read the block count. Then print each block's @type and name. Any type that appears twice with different values is a conflict.

Fix: keep one source per entity. Disable the plugin feature or theme output you do not want. If you need several types on one page, combine them in a single @graph and connect them with @id, as covered in JSON-LD @id and connected schema graphs. A conflict can also hide in plain sight when a site names itself two ways, which is the gap described in the Organization schema check.

This is separate from duplicate pages. When several URLs carry the same content, Google recommends the same structured data on each of them, not only on the canonical [4].

6. Wrong @context or @type

The @context tells a parser which vocabulary the terms belong to. Most Search structured data uses schema.org vocabulary [7]. Common mistakes:

"@context": "schema.org"                  // no scheme
"@context": "https://schema.org/Product"  // a type, not the vocabulary
"@type": "Organisation"                   // UK spelling; schema.org uses Organization
"@type": "article"                        // case matters

Use "@context": "https://schema.org" and copy type names exactly from schema.org. Inside an @graph, put @context once at the top level.

How to spot it: run the page through the Rich Results Test. An unknown type or a property that does not belong to the type is flagged or simply not listed in the detected items [3]. The test tracks Google's supported types, so a valid schema.org type can still show no rich result. Google's own documentation is the reference for what Search uses [7].

7. Dates without a timezone

Schema.org documents ISO-style dates and times, such as YYYY-MM-DD [6]. A timestamp with a time but no offset is ambiguous to any consumer, because it does not say which moment it means [6].

// Ambiguous
"datePublished": "2026-03-04T09:00:00"

// Clear
"datePublished": "2026-03-04T09:00:00-05:00"
"datePublished": "2026-03-04"

Use a date alone if the time does not matter. If it does, include the offset or Z for UTC. Google also asks for up-to-date information, and time-sensitive content that is no longer relevant may not earn a rich result [4]. If dateModified is hard-coded in a template, it will not keep up.

How to spot it: search the block for T followed by a time and no Z or +hh:mm/-hh:mm at the end.

One more cause: the page itself is blocked

Structured-data pages should not be blocked from Googlebot by robots.txt, noindex or other access controls [4]. If markup looks perfect and still is not detected, check the page's status, headers and robots rules before touching the JSON. The technical SEO checklist covers those checks in order.

What to do next

  1. Run the section 2 script on your five most important templates (home, article, product, contact, category).
  2. Fix any block that fails to parse, then any type or @context mistake.
  3. Count blocks per page and remove duplicates at the source.
  4. Test each template in the Rich Results Test and compare the rendered HTML with your raw source [3].
  5. Check the console for CSP violations on any page where the block appears only after load.
  6. For a fuller picture of which types to add, see schema markup for AI search.