JSON-LD for AEO — Which Schema Types Actually Matter

Schema markup was designed for search engines, but AI answer engines have adopted it as a signal layer. When ChatGPT or Perplexity evaluates your page, JSON-LD schema provides structured metadata that is faster and more reliable to parse than inferring meaning from HTML alone. Google uses schema primarily for display — rich results, FAQ dropdowns, star ratings. AI systems use it for something deeper: entity resolution and content evaluation.

FAQPage schema gives the AI pre-formatted question/answer pairs — each one a standalone extraction target. Article schema tells it who wrote the content and when it was last updated, directly feeding the freshness signal that scores 81.2 out of 100 as an AI citation factor (Source: Goodie, 2026). Person schema connects the content to a verifiable entity the AI can cross-reference against LinkedIn, GitHub, and other web mentions. Without these signals, AI systems must guess — and they guess conservatively, favoring pages that make their job easier.

AI engines maintain implicit knowledge graphs — maps of entities and their relationships. Schema.org markup is one of the primary inputs to these graphs. When you add Person schema with sameAs links, you are not just labeling a page — you are telling the AI that a recognized entity created this content and can be verified at these external locations. That entity signal compounds across every page that carries the same schema.

FAQPage schema turns a single page into multiple citation opportunities. Each question/answer pair is an independent extraction target. A page with 10 FAQ entries has 10 distinct chances to be cited when users ask related questions to AI systems.

The questions must be real queries that people actually ask — test them in ChatGPT and Perplexity before writing them. The answers must be complete and standalone, between 40–80 words (up to 120 for complex topics), written in plain prose without bullet points or cross-references to other sections.

In a React or Next.js application, JSON-LD is injected by programmatically creating a script element and appending it to the document head. The useSchema hook below is the actual implementation used on every page of this guide — you can copy it directly.

import { useEffect } from 'react';

export function useSchema(schema: object) {
  useEffect(() => {
    const script = document.createElement('script');
    script.type = 'application/ld+json';
    script.text = JSON.stringify(schema);
    document.head.appendChild(script);
    return () => {
      document.head.removeChild(script);
    };
  }, []);
}

To build a FAQPage schema from an array of question/answer pairs, use a builder function that maps your data to the Schema.org structure:

interface FAQItem {
  question: string;
  answer: string;
}

export function buildFAQSchema(faqs: FAQItem[]) {
  return {
    '@context': 'https://schema.org',
    '@type': 'FAQPage',
    mainEntity: faqs.map((faq) => ({
      '@type': 'Question',
      name: faq.question,
      acceptedAnswer: {
        '@type': 'Answer',
        text: faq.answer,
      },
    })),
  };
}

// Usage in a page component:
const faqs = [
  { question: 'What is AEO?', answer: 'AEO is the practice of...' },
  { question: 'How does AEO differ from SEO?', answer: 'SEO optimizes for...' },
];

useSchema(buildFAQSchema(faqs));

This pattern keeps your FAQ content and your schema markup in sync — a change to the faqs array updates both the visible FAQ section and the JSON-LD simultaneously. No manual schema editing required.

The same builder pattern works for Article schema. Here is the function used in this guide to generate Article JSON-LD with author and freshness signals:

export function buildArticleSchema(options: {
  headline: string;
  description: string;
  slug: string;
  datePublished: string;
  dateModified: string;
}) {
  return {
    '@context': 'https://schema.org',
    '@type': 'Article',
    headline: options.headline,
    description: options.description,
    author: {
      '@type': 'Person',
      name: 'Your Name',
      url: 'https://yoursite.com',
    },
    datePublished: options.datePublished,
    dateModified: options.dateModified,
    mainEntityOfPage: {
      '@type': 'WebPage',
      '@id': `https://yoursite.com/${options.slug}`,
    },
  };
}

The dateModified field is the most critical property for AEO. AI systems use it to evaluate whether your content is current enough to cite. Update it whenever you make meaningful content changes — not for typo fixes, but for factual updates, new sections, or revised claims.

Every page should be validated in Google's Rich Results Test before publishing. Paste the URL, check for errors and warnings, and fix everything. For this guide, we treat warnings as errors — schema inconsistencies can cause AI systems to deprioritize your content even when they don't prevent rich results.

Re-validate after every content change that affects schema: adding FAQ questions, updating dateModified, changing author information, or modifying breadcrumb paths. Schema validation is not a one-time task — it is part of the content update workflow.

A critical rule: the content in your schema must match the visible content on the page. FAQPage schema must contain the same questions and answers that appear in the visible FAQ section. If schema contains content that is hidden from users, Google may revoke rich result eligibility, and AI systems may treat the mismatch as a trust signal violation.