Skip to content
Fix library

How to fix missing structured data (JSON-LD)

Fix missing structured data by adding a JSON-LD script block to each page's head and declaring what the page is using Schema.org types: Organization on every page, Article on editorial content, LocalBusiness on location pages. Validate in Google's Rich Results Test before publishing. This is how engines read page identity instead of inferring it.

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

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.

Article markup: fill the five properties that matter

Add one Article node per article page and complete it. The headline should match the page's real H1. The image should be the article's actual lead image at a usable resolution. Dates go in ISO 8601 format. The doc's own definition of dateModified is “The date and time the article was most recently modified, in ISO 8601 format,” and it recommends including timezone information on both dates.

Author deserves the most care, because it is the field tools butcher most. Use a Person for a human byline or an Organization when the publication itself is the author, and give it a real name. The doc is blunt about keeping that field clean: “Only specify the name of the author. Don't add any other piece of information.” No job titles, no honorifics, no "By " prefix. If the page shows multiple authors, the markup must list all of them.

<!-- A complete Article block. Every value must be true of the page -->
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "How to replace a roof in Austin",
  "image": "https://example.com/images/roof-replacement.jpg",
  "datePublished": "2025-11-03T09:00:00-06:00",
  "dateModified": "2026-07-02T14:30:00-05:00",
  "author": {
    "@type": "Person",
    "name": "Maria Delgado",
    "url": "https://example.com/about/maria-delgado"
  },
  "publisher": {
    "@type": "Organization",
    "name": "Acme Roofing",
    "logo": { "@type": "ImageObject", "url": "https://example.com/logo.png" }
  }
}
</script>

One more alignment check before you ship it. Every value in the block must agree with what a reader sees on the page. The headline matches the H1. The visible byline names the same author as the markup. The visible last-updated date matches dateModified. A block that contradicts the page is worse than no block, because it teaches the engine your typed data lies. If your byline itself is thin or missing, fix that too. Our page on missing author bios covers the visible half of authorship.

FAQPage markup: what changed in August 2023

On August 8, 2023, Google announced it was reducing the visibility of FAQ rich results, the expandable question-and-answer dropdowns that used to appear under a listing in search results. The restriction was explicit. The rich result would be reserved for well-known, authoritative government and health websites. For every other site, the post says plainly: “For all other sites, this rich result will no longer be shown regularly.” A follow-up update on September 14, 2023 went further on the sibling type and deprecated How-To rich results entirely.

That was not a temporary experiment. It was a permanent simplification of the results page, rolled out globally within a week of the announcement. If your business is not a government agency or a recognized health authority, FAQPage markup stopped earning you the dropdown almost three years ago.

Organization markup: one node, on the homepage, with sameAs

Write one Organization node and put it where the documentation says identity lives. Google's guidance is direct: “We recommend placing this information on your home page, or a single page that describes your organization, for example the about us page.” One page, one node. Then remove or disable every duplicate node your plugins emit, so the deliberate one is the only one.

Give it your real name, your canonical url, and a logo at a stable address. Then add sameAs, the property that does the disambiguation work. The doc defines it as “The URL of a page on another website with additional information about your organization,” and you can provide multiple. Point it at profiles that verifiably belong to you: your LinkedIn company page, your social profiles, and your Wikipedia or Wikidata entry if one exists. Each link is a corroborating record. An engine that finds the same name, site, and profiles agreeing with each other can resolve which Acme you are. We keep a short definition of the property in our glossary entry on sameAs.

<!-- One Organization node, on the homepage, and only one -->
<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",
    "https://www.instagram.com/acmeroofing"
  ]
}
</script>

If a more specific type fits, use it. A storefront roofing company is a RoofingContractor, which is still an Organization to the engine but says more. The properties above carry over. What matters is that the node is singular, accurate, and placed on the page that represents the whole business.

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.

See if a machine can read your page.

Paste your link. We check for valid, typed JSON-LD, the properties each type needs, and what is missing. The preview is free.