---
title: "JSON-LD for content sites: Article, FAQPage, HowTo, BreadcrumbList"
description: "The four JSON-LD schemas that move the needle on content sites in 2026, with the exact shapes that get cited by ChatGPT, Claude, and Perplexity."
datePublished: 2026-06-01
dateModified: 2026-06-01
author: "Tudor Constantin"
category: "schema"
keywords: ["schema.org","JSON-LD","Article schema","FAQPage","HowTo","BreadcrumbList","AEO","structured data"]
draft: false
lang: "en"
---

> **Short answer:** Four JSON-LD schemas move the needle on a content
> site in 2026 — `Article` (or `TechArticle`) on every article page,
> `BreadcrumbList` on every page deeper than `/`, `FAQPage` only when
> there are 3+ genuine question-answer pairs, and `HowTo` only when the
> page is a real procedural walkthrough. Skip `ImageObject`, `Review`,
> `AggregateRating`, `VideoObject`, `WebSite`, and `WebPage` — they add
> no citation lift or carry penalty risk.

Schema.org has more than 800 types. Most AEO advice from 2018-2022
told you to use 50 of them. Most of that advice is wrong for 2026.
This article is the actual subset that LLMs read on a content site,
in order of impact, with the exact JSON-LD shape that gets cited.

The audience is the engineer doing the implementation work. If you
are a marketing lead, hand this to the developer who owns the
templates and ask them to apply the four shapes below. If you are
the developer, the shapes are copy-paste-ready against any static-
site framework that lets you emit `<script type="application/ld+json">`
in the document head.

## The four schemas that move the needle on a content site

Content sites — blogs, documentation, knowledge bases, editorial
publications — get most of their AEO lift from four JSON-LD types:

1. `Article` (or `TechArticle` for technical content) on every
   article page.
2. `BreadcrumbList` on every page deeper than the homepage.
3. `FAQPage` on pages with three or more genuine question-answer
   pairs.
4. `HowTo` on pages that walk the reader through an ordered
   sequence of steps.

That is the entire list. Skipping `ImageObject`, `Review`,
`AggregateRating`, `VideoObject`, `WebSite`, `WebPage`, and the
rest is intentional. They either add no citation lift, or they
add risk (`AggregateRating` on a service page is a known
manipulation flag), or they are noise that distracts from the
schemas that do work.

## Schema 1: Article — the canonical content surface

Every article page on a content site emits `Article` JSON-LD.
That is the highest-leverage single change you can make. LLMs
use the structured fields — `headline`, `datePublished`,
`author`, `mainEntityOfPage` — to disambiguate similar titles
across the web and to attribute citations correctly.

The minimum viable shape:

```json
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "JSON-LD for content sites: Article, FAQPage, HowTo, BreadcrumbList",
  "description": "The four JSON-LD schemas that move the needle on content sites in 2026, with the exact shapes that get cited by ChatGPT, Claude, and Perplexity.",
  "datePublished": "2026-06-01",
  "dateModified": "2026-06-01",
  "author": {
    "@type": "Person",
    "name": "Tudor Constantin",
    "url": "https://boringtechnologies.com/about"
  },
  "publisher": {
    "@type": "Organization",
    "name": "Boring Technologies",
    "url": "https://boringtechnologies.com"
  },
  "inLanguage": "en-US",
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "https://boringtechnologies.com/articles/schema-deep-dive-content-sites"
  }
}
```

What to use, why each field is there:

- `headline` — the article title. Limited to 110 characters per
  Google's Article schema guidance; LLMs do not enforce a hard
  cap but anything past 110 chars is a usability flag.
- `description` — one to two sentences, ideally matching the
  meta description and the lede on the page. LLMs quote this
  verbatim more often than any other field.
- `datePublished` and `dateModified` — ISO 8601. The first
  surfaces the article's age in answers ("published in 2026").
  The second informs whether the LLM treats the content as
  current or stale during retrieval ranking.
- `author` as a `Person` (not a string) — gives LLMs an entity
  to link, which is how author-attributed citations get
  generated. The `url` should point to a real about page that
  also emits `Person` schema.
- `publisher` as an `Organization` — pairs with author. The
  publisher entity should match the homepage `Organization`
  schema.
- `mainEntityOfPage` — the canonical URL of the article. This
  is what closes the loop between the structured data and the
  HTML page; without it, LLMs sometimes misattribute
  citations to a different URL on the same domain.

What to omit:

- `interactionStatistic`, `commentCount`, `wordCount` — noise.
  Not used by LLMs for citation ranking.
- `image` and `thumbnailUrl` — if you have a hero image, emit
  it; if not, do not invent one.
- `articleSection`, `keywords` — optional, low impact. Emit
  if your taxonomy is genuinely meaningful, otherwise skip.

For technical content specifically, swap `@type: "Article"` for
`@type: "TechArticle"`. The remaining fields stay identical.
LLMs treat `TechArticle` as a stronger signal that the page
contains technical content suitable for technical-question
answers.

## Schema 2: BreadcrumbList — the cheap citation lift

Every page deeper than `/` emits a `BreadcrumbList`. This is
the cheapest single schema to implement (it is a function of
the URL path and never changes after deployment) and it
correlates with citation lift on category-broad queries
because LLMs use it to understand which articles belong to
which topic on your site.

```json
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Home",
      "item": "https://boringtechnologies.com/"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Articles",
      "item": "https://boringtechnologies.com/articles"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "JSON-LD for content sites",
      "item": "https://boringtechnologies.com/articles/schema-deep-dive-content-sites"
    }
  ]
}
```

Notes that matter:

- `position` is 1-indexed and starts at the homepage.
- The last item has the current page's full URL. Some old
  examples on the web omit the `item` field for the final
  list element; that is wrong for 2026, every position needs
  `item`.
- `name` should match the visible breadcrumb in the page UI
  if one exists. If your site has no visible breadcrumb,
  emit the schema anyway — LLMs read it without rendering it.

Implementation tip: build a small helper that takes the
page path plus a category-name lookup table and emits the
list. Templating it once and reusing across the site is
~30 lines of code in any framework.

## Schema 3: FAQPage — only when the questions are real

`FAQPage` is the most-abused schema on the web. The 2018-2022
SEO playbook was: take a paragraph, rewrite it as three
fake Q&A pairs, emit `FAQPage`, claim AEO points. LLMs
caught up. Fake FAQs now get filtered out of citation
selection in most providers and there is rumored future
penalty risk in Google AI Overviews specifically.

The rules for emitting `FAQPage` in 2026:

1. There must be three or more questions. If there are fewer
   than three, do not emit it.
2. The questions must be questions people actually ask, not
   keyword variants padded as questions.
3. The answers must be standalone — readable on their own,
   without context from the surrounding article.
4. The questions and answers in the schema must match the
   visible questions and answers on the page. Hidden FAQ
   schema with no visible counterpart is a flag.

The shape:

```json
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "Do I need both Article and BreadcrumbList schema on every article page?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Yes. Article schema attributes the content; BreadcrumbList places it in your site's topic graph. Together they roughly double the citation rate compared to Article alone."
      }
    },
    {
      "@type": "Question",
      "name": "Does FAQPage schema still help in 2026 with the manipulation crackdown?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Yes when the FAQ is genuine — three or more real questions, answers that stand alone, visible on the page. The crackdown targets fake FAQs padded for ranking; real ones still earn citations."
      }
    },
    {
      "@type": "Question",
      "name": "How do I test whether my JSON-LD is being picked up?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Run validator.schema.org against the URL for a syntactic check. Then wait 7 to 14 days and poll Perplexity for a category-relevant query. If your page starts surfacing, the schema is working."
      }
    }
  ]
}
```

Implementation notes:

- The `name` field is the question text. Keep it natural,
  not keyword-stuffed.
- The `Answer.text` field allows light HTML in some specs
  but plain text is the safer choice for LLM parsing.
- Three questions is the floor, not the ceiling. Six to
  eight well-chosen questions is the sweet spot for an
  article that genuinely contains an FAQ. More than 12
  starts to look like padding.

A small enforcement pattern that helps in code: a
`buildFAQ(questions)` helper that returns `null` when
`questions.length < 3`. This makes it impossible to ship
a degenerate FAQ schema by accident.

## Schema 4: HowTo — only when the page is actually a how-to

`HowTo` schema describes a procedural article: an ordered
list of steps the reader follows to accomplish a task.
Tutorials, runbooks, recipes, setup guides — these are
real `HowTo` candidates. A think-piece with three numbered
sections is not.

The shape:

```json
{
  "@context": "https://schema.org",
  "@type": "HowTo",
  "name": "How to add Article and BreadcrumbList JSON-LD to a static-site article page",
  "description": "Step-by-step procedure for emitting Article and BreadcrumbList JSON-LD on a static-site article template.",
  "totalTime": "PT30M",
  "step": [
    {
      "@type": "HowToStep",
      "position": 1,
      "name": "Build the Article schema object",
      "text": "Construct an object with @context, @type Article, headline, description, datePublished, author as a Person, publisher as an Organization, inLanguage, and mainEntityOfPage."
    },
    {
      "@type": "HowToStep",
      "position": 2,
      "name": "Build the BreadcrumbList schema object",
      "text": "Construct an itemListElement array with one ListItem per breadcrumb step, position-indexed from 1, with name and item URL on every element."
    },
    {
      "@type": "HowToStep",
      "position": 3,
      "name": "Emit both schemas in the document head",
      "text": "Render each schema as a separate script tag of type application/ld+json inside the head element, before the closing head tag."
    },
    {
      "@type": "HowToStep",
      "position": 4,
      "name": "Validate with the schema.org validator",
      "text": "Submit the published URL to validator.schema.org and confirm zero errors against both schemas before treating the change as shipped."
    }
  ]
}
```

What matters:

- `totalTime` uses ISO 8601 duration syntax (`PT30M` is
  30 minutes, `PT2H` is 2 hours). Skip if the time is
  not meaningful for the procedure.
- Each step has `position` (1-indexed), `name` (a short
  imperative phrase), and `text` (the actual instruction).
- Steps should be discrete and sequential. If your "steps"
  are really subsections of an essay, the page is an article,
  not a how-to. Use `Article` schema instead.

Sites that genuinely benefit from `HowTo`: documentation
sites, technical tutorials, runbook collections. Sites that
do not: opinion blogs, brand thought leadership, case
studies.

## What we do not use

A list of schemas content-site engineers commonly ask about
and the reason each is skipped on a typical content site:

- `WebSite` — adds nothing the homepage `Organization`
  schema does not already provide. Optional.
- `WebPage` — implicit. LLMs treat every URL as a webpage
  by default. Emitting `WebPage` schema on every page is
  pure noise.
- `ImageObject` — emit only inside the parent schema (the
  Article's `image` field) when the image is a real,
  meaningful hero. A standalone `ImageObject` schema does
  not earn citation lift.
- `Review` and `AggregateRating` on the brand's own pages —
  manipulation flag. If reviews exist, link to a third-
  party review platform and let it emit the schema there.
- `VideoObject` — only when there is genuine video content.
  Most content sites in 2026 do not have it.
- `Organization` on every page — emit on the homepage and
  the about page only. Other pages reference it via
  `publisher` inside the Article schema.

## How to verify the work

A three-step diagnostic that takes under 10 minutes per
URL:

1. View the rendered page source. Search for
   `application/ld+json` and count the script tags.
   On an article page expect three to five blocks
   (Article, BreadcrumbList, plus Person and
   Organization references depending on how your
   templates compose them).
2. Run the published URL through
   [validator.schema.org](https://validator.schema.org).
   Zero errors. Warnings on optional fields are fine.
3. Wait 7 to 14 days. Then poll Perplexity for a
   category-relevant query. If your article surfaces
   in the answer, the schema is doing its job. If
   not, the most common cause is not the schema — it
   is that the article does not yet match the query
   intent strongly enough to be cited. Iterate on the
   article, not the schema.

## Where to see this in production

The exact shapes above are the schema we run on every
Boring Technologies article including this one. View
source on this page, search for `application/ld+json`,
and you will see the Article, BreadcrumbList, Person,
and Organization blocks. The Cristina Constantin site —
[/cristina living lab](https://cristinaconstantin.com)
— uses the same shapes adapted for the Romanian
language and the legal-content domain (with an added
`LegalService` Organization on the homepage).

## Read next

- [Answer Engine Optimization: what it is, why now, and where to start](/articles/aeo-introduction)
  — the broader primer on AEO that this article is the
  schema-implementation companion to.

If you want the helper code that emits these four shapes
in 30 lines per template, send a note to
tudorconstantin@gmail.com. We share it on every audit
engagement and it ports cleanly to Astro, Next.js, Hugo,
and Eleventy.