Guide · 14 min read

JSON-LD Structured Data for AI Search: Complete Guide

AI search engines don't read web pages the way humans do. They parse, extract, and synthesize — and if your content isn't structured for machine consumption, it gets skipped. JSON-LD is the single most impactful technical change you can make to improve your visibility in ChatGPT, Perplexity, Google AI Overviews, and Claude. This guide covers everything: what JSON-LD is, which schema types matter for AI search, how to implement them, and how to validate your markup.

TL;DR: If you only do one thing after reading this, add Organization, WebSite, and Article schema to your site. That alone covers 80% of the structured data signals that AI engines look for.

1. What is JSON-LD?

JSON-LD (JavaScript Object Notation for Linked Data) is a structured data format that tells search engines — and now AI models — exactly what your page is about. Instead of hoping a crawler infers that "John Smith" is the author from context, you explicitly declare it in machine-readable form:

A typical JSON-LD block looks like this:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "How to Bake Sourdough Bread",
  "author": {
    "@type": "Person",
    "name": "Jane Dough"
  },
  "datePublished": "2026-07-15",
  "publisher": {
    "@type": "Organization",
    "name": "Baking Weekly"
  }
}
</script>

The key insight: this block is invisible to human readers but trivially parseable by machines. Google, Bing, ChatGPT's crawler (GPTBot), Perplexity, and Claude's crawler (ClaudeBot) all read JSON-LD. When an AI model encounters structured data, it doesn't need to guess — it knows exactly what entity the page describes, who wrote it, when it was published, and how it relates to other entities.

2. Why JSON-LD Matters for AI Search

Traditional SEO uses structured data to earn rich snippets — star ratings, recipe cards, event listings. That's still valuable. But AI search engines use it for something more fundamental: entity disambiguation and fact extraction.

When ChatGPT generates an answer, it synthesizes information from multiple sources. If your page has JSON-LD that clearly identifies the author, publication date, and entity type, the model can:

Extract facts with high confidence — "published on 2026-07-15" is unambiguous in JSON-LD, but ambiguous in prose
Disambiguate entities — "Apple" the company vs "apple" the fruit is resolved by @type and @id
Build knowledge graphs — AI models maintain internal entity graphs; JSON-LD nodes become vertices
Cite with accuracy — when an AI cites your content, it can use the exact headline and author from your schema
Determine freshness — dateModified tells the model whether your content is current

In GeoScore audits, sites with comprehensive JSON-LD score 20-30 points higher on the Structured Data dimension than sites without. It's the single largest technical gap we see.

3. Schema Types That Matter for AI Search

Schema.org defines hundreds of types, but only a handful matter for AI search visibility. Here's the priority order:

Schema Type	Priority	Where to Use	AI Search Impact
`Organization`	Critical	Every page (site-wide)	Entity identity, brand recognition
`WebSite`	Critical	Homepage	Site-level metadata, search action
`Article`	High	Blog posts, news	Content attribution, citation
`FAQPage`	High	FAQ pages, pillar content	Direct answer extraction
`HowTo`	Medium	Tutorials, guides	Step-by-step synthesis
`Product`	Medium	Product pages	Product entity, pricing
`BreadcrumbList`	Low	All pages	Navigation context

A site that implements the top 5 types across all relevant pages will score 80+ on GeoScore's Structured Data dimension. Let's walk through each one.

4. Organization Schema (Required for Every Site)

Organization schema tells AI models who you are as an entity. Without it, your brand is a string of text; with it, your brand is a structured node in the knowledge graph. Place this in the <head> of every page (or inject it via your layout template).

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Organization",
  "@id": "https://yoursite.com/#organization",
  "name": "Your Company Name",
  "url": "https://yoursite.com",
  "logo": "https://yoursite.com/logo.png",
  "description": "One-sentence description of what your company does",
  "foundingDate": "2024",
  "sameAs": [
    "https://twitter.com/yourhandle",
    "https://github.com/yourorg",
    "https://www.linkedin.com/company/yourcompany"
  ]
}
</script>

The sameAs array is particularly important for AI search. It tells the model that your Twitter account, GitHub repo, and LinkedIn page are all the same entity. This cross-platform identity linking is how AI models build trust and verify your brand's authenticity.

5. WebSite Schema (Required for Every Site)

WebSite schema defines your site as an entity and optionally declares a search action. This helps AI models understand your site's scope and enables them to recommend your internal search for relevant queries.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "WebSite",
  "@id": "https://yoursite.com/#website",
  "url": "https://yoursite.com",
  "name": "Your Site Name",
  "publisher": {
    "@id": "https://yoursite.com/#organization"
  },
  "potentialAction": {
    "@type": "SearchAction",
    "target": {
      "@type": "EntryPoint",
      "urlTemplate": "https://yoursite.com/search?q={search_term_string}"
    },
    "query-input": "required name=search_term_string"
  }
}
</script>

Note the publisher field links back to the Organization via @id. This cross-referencing is what turns isolated JSON-LD blocks into a connected graph. AI models follow these @id references the same way web crawlers follow hyperlinks.

6. Article Schema (For Blog Posts)

Every blog post and news article should have Article schema. This is what allows AI models to cite your content accurately — with the correct headline, author, and publication date.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Article",
  "@id": "https://yoursite.com/blog/my-article#article",
  "headline": "Your Article Title (Keep Under 110 Characters)",
  "description": "A concise summary of the article in 1-2 sentences.",
  "image": "https://yoursite.com/images/article-og.png",
  "author": {
    "@type": "Person",
    "name": "Author Name",
    "url": "https://yoursite.com/about/author-name"
  },
  "publisher": {
    "@id": "https://yoursite.com/#organization"
  },
  "datePublished": "2026-07-15",
  "dateModified": "2026-07-20",
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "https://yoursite.com/blog/my-article"
  },
  "keywords": "json-ld, structured data, ai search, geo"
}
</script>

Two fields are especially important for AI search:

dateModified — AI models prioritize recent content. If you update a post, bump this field. Without it, models may treat your content as stale even if it's evergreen.
author.url — linking to an author bio page with Person schema creates an E-E-A-T signal chain. This is how AI models verify that your author is a real person with real expertise.

7. FAQPage Schema (For High-Value Pages)

FAQPage is the most powerful schema type for AI search. When an AI model encounters a FAQPage, it can extract question-answer pairs directly and use them verbatim in generated answers. This is the closest you can get to "programming" an AI's response.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "What is JSON-LD?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "JSON-LD (JavaScript Object Notation for Linked Data) is a structured data format that helps search engines and AI models understand web page content by providing explicit machine-readable metadata."
      }
    },
    {
      "@type": "Question",
      "name": "How does JSON-LD help AI search?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "JSON-LD helps AI search engines like ChatGPT, Perplexity, and Google AI Overviews extract facts with high confidence, disambiguate entities, build knowledge graphs, and cite content with accurate attribution."
      }
    }
  ]
}
</script>

Pro tip: Don't stuff FAQPage with dozens of questions. 4-8 well-written Q&A pairs that directly address common user queries are far more effective than 30 shallow ones. AI models extract the most relevant answer, not all answers.

8. HowTo Schema (For Tutorials)

If you publish step-by-step guides, HowTo schema helps AI models understand the sequential structure of your content. When a user asks "how do I..." an AI can pull your steps and present them in order.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "HowTo",
  "name": "How to Add JSON-LD to Your Website",
  "description": "Step-by-step guide to adding structured data for AI search visibility.",
  "totalTime": "PT15M",
  "step": [
    {
      "@type": "HowToStep",
      "position": 1,
      "name": "Identify your schema types",
      "text": "Determine which schema types your site needs: Organization, WebSite, Article, FAQPage, and HowTo cover most use cases."
    },
    {
      "@type": "HowToStep",
      "position": 2,
      "name": "Write the JSON-LD blocks",
      "text": "Write JSON-LD blocks for each schema type, using the schema.org vocabulary and proper @context and @type fields."
    },
    {
      "@type": "HowToStep",
      "position": 3,
      "name": "Inject into your HTML head",
      "text": "Add the script tags to your HTML head section, or inject them via your CMS or static site generator layout."
    },
    {
      "@type": "HowToStep",
      "position": 4,
      "name": "Validate with testing tools",
      "text": "Use Google Rich Results Test, Schema.org Validator, and GeoScore to validate your markup before deploying."
    }
  ]
}
</script>

9. Product Schema (For E-commerce)

If you sell products, Product schema is essential. AI shopping assistants and recommendation engines rely heavily on structured product data to match user queries with relevant products.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Premium Wireless Headphones",
  "image": "https://yoursite.com/images/headphones.jpg",
  "description": "Noise-cancelling wireless headphones with 40-hour battery life.",
  "brand": {
    "@type": "Brand",
    "name": "YourBrand"
  },
  "offers": {
    "@type": "Offer",
    "price": "199.00",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock",
    "url": "https://yoursite.com/products/headphones"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.7",
    "reviewCount": "342"
  }
}
</script>

10. Implementation: Step by Step

Here's the implementation order we recommend, based on auditing 1,200+ websites:

Add Organization + WebSite schema to your layout template — this goes in the <head> of your base layout so it appears on every page.
Add Article schema to your blog post template — use your CMS or static site generator's frontmatter to populate the fields dynamically.
Add FAQPage schema to your top 3-5 pages — pick the pages that answer the most common user questions about your product or topic.
Add HowTo schema to tutorial content — any step-by-step guide benefits from this.
Add Product schema to product pages — if applicable.
Add BreadcrumbList schema — this is low-effort, low-impact, but completes the picture.

Most static site generators (Astro, Next.js, Hugo, Jekyll) make this easy with template injection. Here's how it looks in an Astro layout:

---
// src/layouts/Layout.astro
const { schema } = Astro.props;
---
<head>
  <script type="application/ld+json" set:html={JSON.stringify({
    "@context": "https://schema.org",
    "@type": "Organization",
    "name": "Your Company",
    "url": "https://yoursite.com",
    "logo": "https://yoursite.com/logo.png"
  })} />
  {schema && (
    <script type="application/ld+json" set:html={JSON.stringify(schema)} />
  )}
</head>

11. Validation and Testing

Before deploying, validate your JSON-LD with these tools:

1.
Google Rich Results Test — search.google.com/test/rich-results
Tests whether Google can parse your structured data and which rich result types it qualifies for.
2.
Schema.org Validator — validator.schema.org
Validates against the schema.org vocabulary. More strict than Google's tool.
3.
GeoScore Audit — geoscore.help
Our free tool checks your structured data as part of the 12-dimension GEO audit and tells you exactly what's missing.

12. Common Mistakes That Tank Your Score

In our audits, these are the most common JSON-LD mistakes we see:

Mistake 1: No JSON-LD at all

60% of sites we audit have zero structured data. This is the #1 reason for low GeoScore ratings. Fix: add Organization + WebSite schema today.

Mistake 2: JSON-LD only on the homepage

Many sites add Organization schema to the homepage and forget the rest. AI crawlers visit deep pages too. Fix: inject site-wide schema via your layout template.

Mistake 3: Missing dateModified

Article schema without dateModified is treated as potentially stale by AI models. Fix: always include both datePublished and dateModified.

Mistake 4: No @id references

Isolated JSON-LD blocks without @id cross-references are treated as separate entities. Fix: use @id URIs to link Organization, WebSite, and Article schemas together.

Mistake 5: Mismatched data

JSON-LD says "published July 15" but the visible page says "June 20". AI models detect inconsistencies and lose trust. Fix: ensure visible content and structured data always match.

13. AI Search-Specific Tips

Beyond the standard schema.org implementation, here are advanced tactics specifically for AI search visibility:

Use sameAs aggressively — link to your Wikipedia page, Crunchbase, GitHub, social media. Every sameAs entry is a trust signal that AI models use to verify your entity.
Add WebApplication schema for tools — if you offer a web tool (like GeoScore), WebApplication with applicationCategory and offers helps AI models understand what your tool does and recommend it.
Include keywords in Article schema — while Google has de-emphasized the keywords field, AI models still use it as a signal for topic classification.
Nest Person schema for authors — don't just use a name string. Create a full Person entity with jobTitle, sameAs (LinkedIn, Twitter), and a bio URL. This creates an E-E-A-T chain that AI models follow.
Use mainEntityOfPage consistently — this tells AI models "this page is primarily about X", which helps with entity extraction and citation accuracy.

14. Complete Checklist

Use this checklist to ensure your JSON-LD implementation is AI-search-ready:

Check Your Structured Data Now

Run a free GeoScore audit to see your structured data score and get specific fix recommendations.

Start Free Audit →

Related reading:

Last updated: 2026-07-24. GeoScore is a free, open-source GEO audit tool. View on GitHub.