How to fix missing structured data (JSON-LD)

Before you add schema, run the free schema checker to see exactly what structured data Google currently reads.

What does missing structured data mean for search?

Missing structured data means search engines and AI have no machine-readable markup telling them what your page represents, so they guess from headings, title, and scraped text instead of reading typed facts.

Structured data describes page content using machine-readable vocabulary. Google supports JSON-LD, Microdata and RDFa. Markup does not certify that its claims are true or guarantee a citation. Validate syntax and agreement with visible content.

The symptom we catch most often is one of two states. The first is no JSON-LD at all, so the engine has nothing to read and falls back to guessing from your headings, your title, and whatever text it can scrape. The second is worse and quieter: JSON-LD that is present but invalid, a stray comma or an unclosed brace that makes the whole block fail to parse. To the engine, broken markup and no markup look the same. Either way, the machine is left inferring your identity instead of reading it, and inference is where citations get awarded to someone else.

What can missing structured data affect?

Missing structured data does not by itself establish a ranking loss. Some supported rich-result features require particular markup; eligibility depends on the feature and the page. Search engines also interpret visible content. Google's structured-data guidelines explain the limits.

A page can be beautifully written for people and say nothing to a parser. A browser renders your logo, your author byline, your publish date, and your business name as pixels. A crawler does not see a logo or a byline. It sees HTML, and unless those facts are also expressed as typed data, it has no reliable way to know that the page is an article published on a given date by a named organization. The gap between what a human reads and what a machine can confirm is exactly the gap structured data closes.

The usual causes are ordinary. A static site was hand-built and the markup was never added. A theme stripped it during a redesign. A plugin emitted JSON-LD with a syntax error that no one noticed because the page still looked fine. A page declared a type, say Article, but omitted properties that type requires, so the block is technically present and practically useless. None of these are visible without looking at the source, which is why this failure persists for months on otherwise healthy sites.

How do I add structured data to my website?

Add a <script type="application/ld+json"> block to the <head> of each page, declare your Organization on every page and Article on content pages, then validate in Google's Rich Results Test before publishing.

1. Add 1 <script type="application/ld+json"> block to the <head> of the page.
2. Declare an Organization with name, url, logo, and sameAs.
3. On content pages, add an Article with headline, image, real dates, author, and publisher.
4. Validate with Google's Rich Results Test and the Schema.org validator, then re-audit the live URL.

Choose markup that accurately describes visible content and a currently supported use case. Organization markup does not certify ownership or validate every other type. Google stopped showing FAQ rich results on May 7, 2026; the old health/government restriction is no longer a current availability rule. Check the official feature updates.

Add a <script type="application/ld+json"> block to the <head> of the page. Start with the two types nearly every site needs. The first is Organization, which establishes who you are. Include name, url, logo, and sameAs linking to your verified profiles:

<!-- Tells engines who publishes this site -->
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "Acme Roofing",
  "url": "https://acmeroofing.com/",
  "logo": "https://acmeroofing.com/logo.png",
  "sameAs": [
    "https://www.linkedin.com/company/acme-roofing",
    "https://www.facebook.com/acmeroofing"
  ]
}
</script>

For a content page, add an Article. It needs at least a headline to be valid, but to clear the recommended tier and give engines the full picture, include image, datePublished, dateModified, author, and publisher. Match the headline to the page's real H1, and use real dates:

<!-- Tells engines what this specific page is -->
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "How to replace a roof in Austin",
  "image": "https://acmeroofing.com/og-image.png",
  "datePublished": "2026-06-14",
  "dateModified": "2026-09-19",
  "author": { "@type": "Organization", "name": "Acme Roofing" },
  "publisher": {
    "@type": "Organization",
    "name": "Acme Roofing",
    "logo": {
      "@type": "ImageObject",
      "url": "https://acmeroofing.com/logo.png"
    }
  }
}
</script>

Two rules keep this honest. Pick the type that actually matches the page, and do not invent it: a service page is not an Article, and a blog post is not a Product. And include every property the type requires, because a partial block is the broken-markup symptom in a different coat. The structured data should describe what is genuinely on the page and nothing more. Markup that claims a rating or a review that does not exist on the page is a violation, not an optimization.

Be honest about what structured data does

Structured data can describe content explicitly, but it does not remove the need to verify the underlying claims. Eligibility and display depend on the supported feature. Compare the markup with visible content and test syntax before and after a change. Google documents these limits.

Verify: validate, then re-audit

Once the markup is in place, confirm it parses and is well-formed. Run the page through Google's Rich Results Test and the Schema.org validator. Both will flag a syntax error, a missing required property, or a type mismatch, which is exactly the class of bug that makes a block silently useless. Fix what they report and run them again until they are clean.

Re-run the audit to confirm what the scanner can capture, then validate the markup with the relevant provider tool. A successful syntax check does not prove that an engine indexed, understood or cited the page.