Key Takeaways
  • **What it is**: An article (as opposed to a product listing, category page, or user-generated forum post)
  • **What it covers**: The headline and description fields give the AI a machine-readable summary
  • **When it was created**: The `datePublished` field establishes the content's original publication date
  • **When it was last touched**: The `dateModified` field tells the AI whether the content is current
  • **Who published it**: The `publisher` field identifies the organization behind the content

Schema markup for AI citation is the single highest-leverage technical change you can make to a page without touching a single word of visible content. It adds zero visual changes, zero JavaScript overhead, zero impact on page speed, and it makes your pages roughly 3x more likely to be cited by AI search engines. Among the top-cited pages in our research at GetCited, 76% use Article schema and 56% use FAQ schema. Those numbers are not a coincidence. They reflect the fact that AI systems prioritize pages where structured data explicitly tells them what the content is, who wrote it, when it was published, and what questions it answers.

If you have been ignoring structured data because it felt like an SEO technicality from 2018, it is time to reconsider. Schema markup has become one of the primary ways AI engines decide which pages are worth citing and which get skipped entirely.

This guide walks through the exact JSON-LD schema types that correlate with AI citations, gives you copy-paste code templates for each one, and explains why they matter in practical terms. No theory. No fluff. Just the types that work and the code to implement them.

Why Schema Markup Matters More for AI Than It Ever Did for Google

Traditional search engines used schema markup mostly for rich snippets. You added Recipe schema to get star ratings in Google results. You added Event schema to get date displays. The reward was visual: a slightly fancier search listing that might improve click-through rates by a few percentage points.

AI search engines use schema markup for something fundamentally different. They use it to understand what your page actually is before they start reading it.

When ChatGPT Search, Perplexity, or Google's AI Overviews evaluate your page as a potential citation source, the structured data in your JSON-LD is one of the first things the system processes. It functions like a table of contents and a credential check rolled into one. The schema tells the AI: this is an article (not a product page, not a forum post), it was written by this person with these credentials, it was published on this date and last updated on this date, and it answers these specific questions.

That context matters enormously during the citation selection process. AI systems are evaluating dozens of candidate pages for every query. The pages that make it easy for the system to verify relevance, recency, and authority have a structural advantage over pages that force the AI to figure all of that out by parsing raw HTML.

Think of it this way. Two pages contain identical information about retirement account contribution limits. One has Article schema declaring the author, publication date, and last modified date. The other is an unstructured blog post with no metadata beyond a title tag. The AI can verify the first page's recency and authorship in milliseconds. For the second page, it has to infer everything from context clues in the body text. Which one do you think gets cited?

The JSON-LD Basics (For Those Who Have Never Touched Schema)

Before we get into the specific types, let's cover what JSON-LD actually is and how it works.

JSON-LD stands for JavaScript Object Notation for Linked Data. Despite the name, it is not JavaScript in any functional sense. It does not execute. It does not affect your page's rendering. It does not slow anything down. It is a block of structured data that sits in your page's <head> section (or anywhere in the HTML, technically) inside a <script> tag with the type attribute set to application/ld+json.

Here is what the basic wrapper looks like:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "Your Article Title Here"
}
</script>

That is it. You paste a block of structured data into your page's HTML template, and every crawler that visits the page can immediately read that metadata. No API calls. No external scripts. No render-blocking resources. It is pure data declaration.

Every CMS handles this differently. WordPress has plugins like Yoast and RankMath that generate some schema automatically. If you use a static site generator, you add it to your templates. If you use a custom CMS, you drop it into the HTML head. The implementation path varies, but the JSON-LD itself is universal.

Now let's get into the four schema types that actually move the needle for AI citations, plus one bonus type that is increasingly relevant for procedural content.

Type 1: Article Schema (Tells the AI What the Page Is About)

Article schema is the foundation. It tells AI systems that your page is a piece of editorial content and provides the key metadata they need to evaluate it as a citation source.

Among pages that earn AI citations, 76% have Article schema implemented. That makes it the single most common schema type on cited pages, and the one you should implement first if you have not started yet.

What Article Schema Communicates to AI

Article schema provides the AI with a structured summary of the page's identity:

The dateModified field deserves special attention. AI engines heavily weight recency when selecting citation sources. A page that was last updated three weeks ago will generally beat a page with identical content that was last updated two years ago. Article schema is how you communicate that recency in a format the AI can parse instantly, without having to scan the body text for phrases like "updated March 2026."

Copy-Paste Article Schema Template

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "Your Article Title Here",
  "description": "A concise 1-2 sentence summary of what this article covers and the key takeaway.",
  "image": "https://yourdomain.com/images/article-featured-image.jpg",
  "datePublished": "2026-01-15T08:00:00+00:00",
  "dateModified": "2026-03-20T10:30:00+00:00",
  "author": {
    "@type": "Person",
    "name": "Author Name",
    "url": "https://yourdomain.com/about/author-name"
  },
  "publisher": {
    "@type": "Organization",
    "name": "Your Company Name",
    "logo": {
      "@type": "ImageObject",
      "url": "https://yourdomain.com/logo.png"
    }
  },
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "https://yourdomain.com/your-article-url"
  }
}
</script>

Implementation Notes

Update dateModified whenever you update content. This is the single most important field for AI citation purposes. If you substantially update an article, update this timestamp. Many CMS platforms do this automatically, but verify that yours actually does. A stale dateModified timestamp on frequently updated content is worse than not having the field at all, because it actively tells AI systems your content is old.

Use ISO 8601 format for dates. That means YYYY-MM-DDTHH:MM:SS+00:00. Do not use human-readable formats like "March 20, 2026" in the schema. Save those for the visible page content.

The description field should be a real summary. Do not just repeat your meta description. Write a genuine one-to-two-sentence summary of the article's core argument or finding. AI systems use this field to quickly assess topical relevance.

Type 2: Organization Schema (Tells the AI Who You Are)

Organization schema establishes the entity behind your content. For AI citation purposes, it answers a basic but critical question: who is publishing this, and are they a real, verifiable organization?

This matters because AI engines are increasingly focused on source credibility. An article published by an identifiable organization with a verifiable web presence, social profiles, and contact information signals more authority than content from an anonymous or unverifiable source.

What Organization Schema Communicates to AI

The sameAs property is particularly powerful for AI systems. It links your organization to your verified profiles on other platforms, helping the AI cross-reference your entity across the web. When ChatGPT or Perplexity encounters your domain, these connections help the system build a more complete understanding of who you are and how established your presence is.

Copy-Paste Organization Schema Template

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "Your Company Name",
  "url": "https://yourdomain.com",
  "logo": {
    "@type": "ImageObject",
    "url": "https://yourdomain.com/logo.png",
    "width": 300,
    "height": 60
  },
  "description": "A brief description of what your organization does and its area of expertise.",
  "foundingDate": "2020",
  "sameAs": [
    "https://twitter.com/yourcompany",
    "https://www.linkedin.com/company/yourcompany",
    "https://github.com/yourcompany"
  ],
  "contactPoint": {
    "@type": "ContactPoint",
    "contactType": "customer support",
    "email": "hello@yourdomain.com"
  }
}
</script>

Implementation Notes

Place Organization schema on your homepage and About page at minimum. You do not need it on every single blog post. The Article schema on individual posts references the publisher, which links back to the organization. But having the full Organization schema on your core pages gives AI crawlers the detailed entity information they need.

Fill out sameAs completely. Every legitimate social profile your organization maintains should be listed. This is how AI systems verify that your organization is a real, active entity with a presence across the web. Empty sameAs arrays are a missed opportunity.

Include foundingDate if your organization has been around for a while. Longevity is a trust signal. An organization founded in 2015 carries different weight than one founded last month. Let the AI know.

Type 3: FAQ Schema (Structures Q&A Pairs AI Can Directly Pull)

FAQ schema is the most directly actionable schema type for AI citation. It does something no other schema type does: it pre-packages your content into question-and-answer pairs that an AI can match directly against user queries.

Among AI-cited pages, 56% use FAQ schema. The reason is straightforward. When a user asks an AI engine a question, the system is literally looking for questions and answers. FAQ schema hands them exactly that, in a structured format, with no parsing required.

Why FAQ Schema Is So Effective for AI Citation

Consider what happens when a user asks Perplexity, "What is the best retirement account for self-employed people?" The AI sends that query out, pulls back candidate pages, and starts evaluating which ones answer the question.

If your page has FAQ schema with the question "What is the best retirement account for self-employed people?" and a corresponding answer, the AI does not even need to read your full article to determine relevance. The structured data has already told it: yes, this page answers that exact question, and here is the answer.

That matching process happens before the AI digs into the body content. FAQ schema essentially puts you at the front of the line for any query that matches one of your declared questions.

Copy-Paste FAQ Schema Template

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "What is schema markup and why does it matter for AI search?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Schema markup is structured data embedded in your page's HTML that tells AI search engines what your content is about, who wrote it, and when it was last updated. It matters for AI search because pages with schema markup are approximately 3x more likely to be cited by AI engines like ChatGPT and Perplexity."
      }
    },
    {
      "@type": "Question",
      "name": "Does FAQ schema still work for Google in 2026?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Google reduced FAQ rich results to only government and health authority websites in 2023. However, FAQ schema remains highly valuable for AI search citation. 56% of pages cited by AI engines use FAQ schema, regardless of Google's rich result policies."
      }
    },
    {
      "@type": "Question",
      "name": "How many FAQ items should I include per page?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Include 3 to 8 FAQ items per page, each addressing a genuine question your audience asks about the topic. Focus on questions that match real search queries rather than artificially stuffing questions for keyword purposes."
      }
    }
  ]
}
</script>

Implementation Notes

Match your FAQ questions to real queries people ask. Do not make up questions nobody searches for. Use Google's "People Also Ask" data, AnswerThePublic, or your own search console query data to identify the actual questions your audience types. The closer your FAQ questions match real user queries, the more directly an AI can match them.

Keep answers self-contained. Each answer should fully address the question without requiring the reader (or the AI) to go read other parts of the page. If the AI extracts your FAQ answer, it should work as a standalone response.

Do not duplicate your entire article as FAQ. FAQ schema should complement your article content, not restate it. Use it for the most common and most directly answerable questions related to your topic. The body of your article handles the depth and nuance.

Yes, use FAQ schema even though Google pulled back on FAQ rich results. Google's decision to limit FAQ rich results to certain site categories in 2023 confused a lot of marketers into thinking FAQ schema was dead. It is not dead. It is more alive than ever for AI citation purposes. Google's rich result policy and AI citation are completely separate systems.

Type 4: Author Schema (E-E-A-T Signals for AI Trust)

Author schema tells AI systems who created the content and what qualifies them to write about the topic. This directly feeds into what Google calls E-E-A-T (Experience, Expertise, Authoritativeness, Trustworthiness) and what AI engines use as credibility signals when deciding whether to cite a source.

An anonymous blog post and an article written by a named expert with verifiable credentials are treated very differently by AI systems. Author schema is how you make the distinction explicit.

What Author Schema Communicates to AI

The sameAs property on author schema works the same way it does on organization schema. It helps the AI cross-reference the author across the web. If your author has a LinkedIn profile, a personal website, published research, or contributions on other authoritative sites, those connections strengthen the credibility signal.

Copy-Paste Author Schema Template

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Person",
  "name": "Jane Martinez",
  "url": "https://yourdomain.com/about/jane-martinez",
  "jobTitle": "Senior Financial Analyst",
  "worksFor": {
    "@type": "Organization",
    "name": "Your Company Name",
    "url": "https://yourdomain.com"
  },
  "description": "Jane Martinez is a senior financial analyst with 12 years of experience in retirement planning and tax-advantaged investment strategies.",
  "sameAs": [
    "https://www.linkedin.com/in/janemartinez",
    "https://twitter.com/janemartinez"
  ],
  "alumniOf": {
    "@type": "CollegeOrUniversity",
    "name": "University of Michigan"
  },
  "knowsAbout": [
    "retirement planning",
    "tax-advantaged accounts",
    "financial analysis",
    "investment strategy"
  ]
}
</script>

Connecting Author Schema to Article Schema

The real power of author schema comes when you connect it to your article schema. In the Article schema template above, the author field references a Person type. You can either embed the full author details inline (within the Article schema) or use a separate Person schema block with an @id to link them.

Here is the inline approach, which is simpler for most implementations:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "Your Article Title",
  "datePublished": "2026-01-15T08:00:00+00:00",
  "dateModified": "2026-03-20T10:30:00+00:00",
  "author": {
    "@type": "Person",
    "name": "Jane Martinez",
    "url": "https://yourdomain.com/about/jane-martinez",
    "jobTitle": "Senior Financial Analyst",
    "worksFor": {
      "@type": "Organization",
      "name": "Your Company Name"
    },
    "sameAs": [
      "https://www.linkedin.com/in/janemartinez"
    ]
  },
  "publisher": {
    "@type": "Organization",
    "name": "Your Company Name",
    "logo": {
      "@type": "ImageObject",
      "url": "https://yourdomain.com/logo.png"
    }
  }
}
</script>

Implementation Notes

Every article needs an author. Unattributed content is a credibility problem for AI citation. Even if your organization is the "author" in a practical sense, attach a named person. AI systems are built to evaluate human expertise.

The knowsAbout property is underused and valuable. It explicitly declares the author's areas of expertise, which helps AI systems match the author's qualifications to the topic of the content. If your author writes about financial planning, listing their knowledge areas helps the AI confirm they are qualified to be cited on that topic.

Link to a real author bio page. The url field should point to a page on your site that has the author's full biography, credentials, and links to their other published work. This gives the AI a place to verify the author's identity and expertise.

Bonus Type: HowTo Schema for Step-by-Step Content

If you publish any kind of instructional or tutorial content, HowTo schema is your secret weapon. It structures procedural content into discrete, numbered steps that AI systems can extract and present as ordered instructions.

This schema type is particularly effective for queries that start with "how to," "steps to," or "guide to." AI engines love citing step-by-step content because it maps perfectly to the format users expect for procedural questions.

Copy-Paste HowTo Schema Template

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "HowTo",
  "name": "How to Add Schema Markup to Your Website",
  "description": "A step-by-step guide to implementing JSON-LD schema markup on your website for better AI search visibility.",
  "totalTime": "PT30M",
  "estimatedCost": {
    "@type": "MonetaryAmount",
    "currency": "USD",
    "value": "0"
  },
  "step": [
    {
      "@type": "HowToStep",
      "name": "Identify your page type",
      "text": "Determine whether your page is an article, FAQ page, product page, or how-to guide. This determines which schema type to use as the primary markup.",
      "position": 1
    },
    {
      "@type": "HowToStep",
      "name": "Choose the appropriate JSON-LD template",
      "text": "Select the JSON-LD template that matches your page type. For articles, use Article schema. For Q&A content, use FAQPage schema. For tutorials, use HowTo schema.",
      "position": 2
    },
    {
      "@type": "HowToStep",
      "name": "Customize the template with your content details",
      "text": "Replace the placeholder values in the template with your actual content details: headline, author name, publication date, description, and any other relevant fields.",
      "position": 3
    },
    {
      "@type": "HowToStep",
      "name": "Add the JSON-LD to your page HTML",
      "text": "Paste the completed JSON-LD block into your page's HTML, ideally in the head section. Wrap it in a script tag with type attribute set to application/ld+json.",
      "position": 4
    },
    {
      "@type": "HowToStep",
      "name": "Validate with Google's Rich Results Test",
      "text": "Run your page URL through Google's Rich Results Test at search.google.com/test/rich-results to confirm the schema is valid and error-free.",
      "position": 5
    }
  ]
}
</script>

Implementation Notes

Use HowTo schema only for genuinely procedural content. Do not force it onto content that is not actually a set of sequential steps. AI systems are smart enough to recognize when the schema does not match the content, and mismatched schema can hurt rather than help.

Each step should be self-contained. Write each step so that it makes sense on its own. AI engines may extract individual steps rather than the entire sequence, especially if a user's query is about a specific part of the process.

Include totalTime when relevant. Letting the AI know that a process takes 30 minutes versus 3 hours helps it match your content to queries that include time constraints.

Combining Multiple Schema Types on a Single Page

You are not limited to one schema type per page. In fact, the most effectively cited pages typically combine multiple schema types to give AI engines a complete picture.

A typical blog post might include:

  1. Article schema for the page's core identity and metadata
  2. Author schema (embedded in Article or standalone) for credibility signals
  3. FAQ schema for the 3-5 most common questions the article addresses
  4. Organization schema for publisher identity (if not already on the homepage)

You can include multiple JSON-LD blocks on the same page, each in its own <script type="application/ld+json"> tag. There is no limit and no performance penalty. Each block is just a small piece of text in your HTML.

Here is what the HTML structure looks like with multiple schema blocks:

<head>
  <!-- Article Schema -->
  <script type="application/ld+json">
  {
    "@context": "https://schema.org",
    "@type": "Article",
    "headline": "Schema Markup for AI: The JSON-LD Types That Get You Cited",
    "datePublished": "2026-03-24T08:00:00+00:00",
    "dateModified": "2026-03-24T08:00:00+00:00",
    "author": {
      "@type": "Person",
      "name": "Your Author Name",
      "jobTitle": "Your Title",
      "url": "https://yourdomain.com/about/author"
    },
    "publisher": {
      "@type": "Organization",
      "name": "Your Company Name",
      "logo": {
        "@type": "ImageObject",
        "url": "https://yourdomain.com/logo.png"
      }
    },
    "description": "A practical guide to the JSON-LD schema types that increase your chances of being cited by AI search engines.",
    "mainEntityOfPage": "https://yourdomain.com/schema-markup-ai"
  }
  </script>

  <!-- FAQ Schema -->
  <script type="application/ld+json">
  {
    "@context": "https://schema.org",
    "@type": "FAQPage",
    "mainEntity": [
      {
        "@type": "Question",
        "name": "Does schema markup affect page speed?",
        "acceptedAnswer": {
          "@type": "Answer",
          "text": "No. JSON-LD schema markup is plain text embedded in your HTML. It adds no JavaScript execution, no external requests, and no rendering overhead. A typical schema block adds less than 2KB to your page weight."
        }
      }
    ]
  }
  </script>
</head>

How to Validate Your Schema Markup

Implementing schema is only half the job. You also need to verify it is valid, error-free, and actually doing what you think it is doing.

Google's Rich Results Test

The fastest validation tool is Google's Rich Results Test at search.google.com/test/rich-results. Paste your URL or your raw code, and it will flag any structural errors, missing required fields, or warnings about recommended fields you have not included.

Schema.org Validator

For a more thorough check, use the Schema Markup Validator at validator.schema.org. It validates against the full schema.org specification rather than just Google's subset, which means it catches issues that the Rich Results Test might miss.

Common Validation Errors to Watch For

The "Zero Overhead" Reality: Why There Is No Reason Not to Do This

Let's address the most common objection head-on. Some development teams resist schema markup because they see it as "extra work" or worry about "technical debt." Here is the reality.

Zero visual changes. JSON-LD schema is completely invisible to your visitors. It does not alter your layout, your design, or your content in any way. If you add schema to a page and do not tell anyone, nobody browsing your site will notice.

Zero JavaScript execution. Despite being in a <script> tag, JSON-LD does not execute as JavaScript. The application/ld+json type attribute tells the browser to treat it as data, not code. It will never conflict with your existing scripts, cause console errors, or trigger any rendering behavior.

Zero impact on page speed. A full schema block with Article, Author, and FAQ markup combined typically adds less than 2-3KB to your page weight. For reference, a single small image on your page is 50-200KB. Schema markup is a rounding error in your page load time.

Massive upside for AI citation. Pages with schema markup are approximately 3x more likely to be cited by AI search engines. That is a return on investment that is hard to match with any other single technical change.

The cost-benefit analysis is as lopsided as it gets. Minutes of implementation time for a 3x increase in citation probability. If there is a lower-effort, higher-impact optimization available for AI search, we have not found it.

How GetCited Checks Schema as Part of Its Page Audit

When you run a page through GetCited's audit process, schema markup analysis is one of the core checks. The audit evaluates:

This is not a yes/no checkbox. The GetCited audit looks at the quality and completeness of your schema implementation, because a bare-minimum schema with just a headline and nothing else is not going to move the needle. The fields matter. The details matter. And AI engines are reading all of them.

If your pages are missing schema entirely, or if your schema is incomplete or structurally broken, the GetCited audit flags it as a priority fix. It is one of the fastest wins you can implement, and it directly impacts your citation probability across every major AI search platform.

A Realistic Implementation Plan

If you are starting from zero, here is the order of operations that delivers the most impact in the least time.

Week 1: Article schema on your top 10 pages. Identify the 10 pages on your site that you most want AI engines to cite. Add full Article schema to each one, including headline, description, datePublished, dateModified, author, and publisher. Validate each one.

Week 2: FAQ schema on those same pages. For each of those 10 pages, identify 3-5 questions that your target audience asks about the topic. Add FAQ schema with complete, self-contained answers. These should be real questions from your search console data or "People Also Ask" results.

Week 3: Organization schema on your homepage and About page. Add a complete Organization schema block to your homepage with name, URL, logo, description, sameAs links to all your social profiles, and contact information. Add it to your About page as well.

Week 4: Author schema for your content creators. Create or update author bio pages for each person who publishes content on your site. Add Person schema to each bio page with name, jobTitle, worksFor, description, sameAs, and knowsAbout.

Ongoing: Schema on every new piece of content. Once you have templates set up, adding schema to new content takes less than five minutes per page. Build it into your publishing workflow so it happens automatically.

Mistakes That Undermine Your Schema Markup

Even with the right types in place, there are implementation mistakes that can reduce or eliminate the benefit.

Stale dateModified timestamps. If you update an article but do not update the dateModified field in your schema, you are actively telling AI systems that your content has not changed. Some CMS configurations auto-generate dateModified on publish but never update it. Check yours.

Generic or missing descriptions. The description field in Article schema is not a throwaway. AI engines use it as a quick relevance check. "This article discusses various topics related to finance" is useless. "A comparison of Roth IRA and Traditional IRA contribution limits, tax treatment, and withdrawal rules for 2026" is useful. Be specific.

Fake or inflated author credentials. AI systems can cross-reference author claims against other sources on the web. If your schema claims someone is a "leading expert in artificial intelligence" but their LinkedIn shows they are a junior marketing coordinator, the credibility signal breaks down. Be accurate.

FAQ questions that nobody asks. Writing FAQ questions that are just keyword-stuffed variations of your target term does not help. AI engines can tell the difference between a real question ("What is the contribution limit for a Roth IRA in 2026?") and a stuffed one ("What are the best Roth IRA contribution limits best 2026 top?"). Write for humans who happen to be asking a machine.

Orphaned schema that does not match page content. If your Article schema says the headline is "Guide to Retirement Planning" but your actual H1 says "Everything About Money," the mismatch is a red flag. Schema should reflect what is actually on the page, not what you wish the page was about.

What Schema Cannot Do (Setting Expectations)

Schema markup is not magic. It is a structural advantage that stacks on top of good content, not a replacement for it.

If your content is thin, outdated, or does not actually answer the query a user is asking, no amount of schema will save it. AI engines read the schema first, but they still read the content. Schema gets you through the door. Content quality determines whether you stay.

Similarly, schema alone will not fix technical access issues. If your robots.txt blocks AI crawlers, or if your page requires JavaScript rendering that AI bots cannot execute, the schema is irrelevant because the AI never sees it.

Schema markup for AI works best as part of a complete optimization stack: strong content, proper crawler access, clear page structure, and then schema on top to tie it all together. That is the approach we recommend at GetCited, and it is the approach that consistently produces the best citation outcomes.

Frequently Asked Questions

Does schema markup for AI actually increase citations, or is it just correlation?

The 3x citation increase for pages with schema markup reflects a strong correlation from analyzing pages that AI engines actually cite. While we cannot definitively prove that adding schema causes more citations (since cited pages tend to be better-optimized overall), the mechanism is logical. Schema makes it easier for AI to understand, evaluate, and cite your content. Pages that reduce friction for AI systems get cited more. Whether schema is the direct cause or one of several contributing factors, the practical takeaway is the same: implement it.

Which JSON-LD schema type should I add first if I can only do one?

Article schema. It is the most commonly found schema type on AI-cited pages (76% of cited pages use it), and it provides the broadest set of useful metadata: what the content is, when it was published, when it was updated, and who wrote it. FAQ schema is a close second if your content naturally answers specific questions, but Article schema is the foundation everything else builds on.

Can I use schema markup generators, or do I need to write JSON-LD by hand?

Schema generators are fine for getting started. Tools like Merkle's Schema Markup Generator, Yoast's WordPress plugin, and RankMath all produce valid JSON-LD. The templates in this article are designed to be copied and customized directly. The key is reviewing the output to make sure all fields are filled with accurate, specific information rather than placeholder text. A generated schema with empty or generic fields is worse than a hand-written one with complete data.

Does FAQ schema still provide value now that Google removed FAQ rich results for most sites?

Absolutely. Google's decision to restrict FAQ rich results to government and health authority sites (made in August 2023) has no bearing on how AI search engines use FAQ schema. ChatGPT Search, Perplexity, Google AI Overviews, and other AI systems still parse FAQ schema to identify question-answer pairs on your page. The 56% FAQ schema usage rate among AI-cited pages is measured independently of Google's rich result policies. FAQ schema for AI citations is alive and well.

Run your pages through a validation tool like Google's Rich Results Test or Schema.org's validator to confirm the markup is structurally sound. Beyond validation, use GetCited's page audit to see how your schema implementation stacks up against the patterns found in pages that actually earn AI citations. The audit checks not just whether schema exists, but whether it includes the fields and level of detail that correlate with citation success. You can also monitor your AI search visibility directly by tracking whether AI engines cite your pages for your target queries over time.