---
title: "Article, Speakable and FAQPage: What Each Schema Type Does"
url: https://hostmy.blog/schema-markup-guide-ai/
date: 2026-09-19
modified: 2026-11-05
lang: en
author: "Aditya Sharma"
description: "Three schema types earn their place for AI retrieval. Here is what each one actually buys you, with the JSON-LD and the test command."
categories:
  - "AI Search"
image: https://hostmy.blog/wp-content/uploads/2026/09/hmb-card-1879-1024x538.jpg
word_count: 1444
---

# Article, Speakable and FAQPage: What Each Schema Type Does

\n*Update, 4 November 2026: we removed statistics from a third-party citation study (self-published, with sentence data from Gemini only), including three claims we could not find in it, rewrote the Speakable and FAQPage sections to match what Google documents (FAQ rich results ended in May 2026, Speakable is a limited beta), and added Pro and pricing information. The title is unchanged.*

\n\n\n
Schema markup does one useful thing for an AI retrieval agent: it states, in a format that needs no parsing guesswork, what the page is, when it changed and who wrote it. Three types carry most of that weight. Article, Speakable and FAQPage.

Everything else on schema.org is either irrelevant to this job or a rich-result play that belongs in a different conversation. Markup is one item on [the list of WordPress tasks AI search advice maps to](/ai-search-optimization-wordpress/), and this piece covers the three types, what each one buys, and how to check yours is actually being served.

Start with the check, because a surprising amount of schema exists only after JavaScript runs.

## Schema that needs JavaScript to appear does not exist

A retrieval agent fetching your URL gets the raw HTML response. If your structured data is injected client side, it is not in that response.

`curl -sS https://example.com/your-post/ | grep -c 'application/ld+json'`

Zero means no JSON-LD in the raw HTML. Compare that against what a rendering validator shows you in a browser, and if the browser shows schema while curl shows none, the schema is being added after load. The longer version of that comparison, [validating JSON-LD from the command line](/check-schema-without-google/), does not need a browser at all.

To read what is actually there:

`curl -sS https://example.com/your-post/ \
| grep -o '"@type": *"[^"]*"' | sort | uniq -c`

That gives a count of every type on the page. Two things to look for: the types you expected, and the types you did not. Plugin stacks accumulate schema, and a page carrying nine entity types is telling an agent nine things at once, which is [the duplicate-node problem in a WordPress plugin stack](/schema-plugin-wordpress/) in its most visible form.

## Article buys you the date and the author

Article is the base type and the one that does real work. Its value is not the type name. It is `dateModified` and `author`.

A page with no machine-readable date gives a parser nothing to compare.

Article schema is how you supply the date without relying on an agent parsing "Last updated: March" out of a sidebar.

`{
"@context": "https://schema.org",
"@type": "Article",
"headline": "Your post title, under 110 characters",
"datePublished": "2025-11-04T09:00:00+00:00",
"dateModified": "2026-08-19T14:20:00+00:00",
"author": {
"@type": "Person",
"name": "Full Name",
"url": "https://example.com/author/full-name/"
},
"publisher": {
"@type": "Organization",
"name": "Your Site"
},
"mainEntityOfPage": "https://example.com/your-post/"
}`

One rule that gets broken constantly: `dateModified` must reflect a real edit. Bumping it nightly on unchanged content is a lie told in a machine-readable format, which is a worse class of lie than the ordinary kind. Which pages genuinely deserve a refresh is the subject of [the delete, redirect or refresh decision](/content-pruning-for-ai/).

The `author` block matters for a different reason. A `Person` with a URL points at a page that can carry credentials. A bare string cannot. [The full Person and FAQPage markup for WordPress](/structured-data-wordpress/) covers the fields worth filling in.

## Speakable marks the sentences suited to reading aloud

Speakable exists to nominate specific passages as the ones worth reading aloud. It lets you point at particular sentences rather than a whole page. Google documents it as a beta for English content and US Google Home devices, aimed at news and Google Assistant (Google Search Central, last updated 8 September 2026, read 4 November 2026).

Google recommends about 20 to 30 seconds of audio per speakable section, roughly two to three sentences.

So keep the nominated passage short. If the passage you mark as speakable runs a full paragraph, it is too long to read aloud as a summary.

`{
"@context": "https://schema.org",
"@type": "Article",
"speakable": {
"@type": "SpeakableSpecification",
"cssSelector": [".rnrd-answer", "h1"]
}
}`

The `cssSelector` form is the practical one. Give your answer sentence a class, put that class in the selector, and the nomination survives every future edit to the paragraph around it.

Speakable has documented eligibility limits on Google's side, so treat it as a way of declaring structure rather than a feature request. Check Google's current documentation before assuming any particular surface consumes it.

Placement still matters for readers. A speakable passage two thirds of the way down is nominating a sentence in the part of the page that is read least.

## FAQPage buys you short question and answer pairs in exactly the right shape

The format of FAQPage is its own argument. Every entry is a question and a self-contained answer.

`{
"@context": "https://schema.org",
"@type": "FAQPage",
"mainEntity": [{
"@type": "Question",
"name": "How long does setup take?",
"acceptedAnswer": {
"@type": "Answer",
"text": "Setup takes about five minutes."
}
}]
}`

That answer is five words, it makes exactly one claim, and it needs no surrounding context to make sense.

Google stopped showing FAQ rich results on 7 May 2026 and removed the documentation on 15 June 2026 (Google Search Central changelog, read 4 November 2026), so do not build an FAQPage block expecting a visual result. Build it only if the questions are on the page and useful to readers. It forces you to write self-contained answers.

We have no source for what other systems do with FAQPage markup, so we claim nothing about it.

Two failure modes to avoid. Do not mark up questions that are not on the visible page, because that is a mismatch between what a person sees and what a machine reads. And do not pad answers to three sentences for search engines, because padding makes the answer harder to read.

Three schema types and what each is for

Three schema types and what each is for

Rendered by JavaScript
schema that needs JS to appear does not exist

Article
the date and the author

Speakable
marks the sentences suited to reading aloud

FAQPage
question and answer pairs in exactly the right shape

Each type answers one question a parser is already asking. Anything rendered after page load answers none of them, because the parser has gone.

## Order and nesting matter as much as the schema

Structured data does not rescue a badly ordered document. Keep headings sequential, H2 then H3, without skipping levels.

The counterweight is real: order is the signal, not volume. Order them properly and use fewer of them.

Readability is a separate job, covered in [four curl checks for whether a page is easy to fetch and read](/ai-seo-checker-curl/). Schema does not change it; sentence construction does.

## What schema cannot do

Schema declares. It does not persuade.

No markup makes an assistant choose, cite or show a page. Nobody outside those systems can promise otherwise.

What markup does is remove ambiguity about what the page is, when it changed and who stands behind it. That is a crawlability and parseability improvement, and it is worth doing on its own terms. Treat any claim beyond that with suspicion.

## Generating this without hand-editing every post

Hand-writing Article, Speakable and FAQPage JSON-LD for every post is what RankReady exists to skip. It outputs all three as JSON-LD, Article once a post has a generated summary and FAQPage when it has FAQs, and adds the Markdown endpoint, robots.txt with Content Signals, an author box and llms.txt. About five minutes to set up, and it runs alongside Rank Math, Yoast, AIOSEO or SEOPress and adds no sitemap of its own.

One thing worth doing right after installing: run the `uniq -c` command above again. A stack already emitting Article from two sources should emit it from one. The plugin is on [the WordPress.org directory](https://wordpress.org/plugins/rankready-ai-llm-seo/), and the wider request chain it sits in is described in [the request chain between a question and your server](/ai-crawlers-request-by-request/).

\n\n\n\nWhere Pro fits: Article, FAQPage and Speakable schema are in the free plugin, and generating summaries and FAQs by hand is unlimited with your own AI provider key. Article schema needs a stored AI summary on the post first. Pro adds generation on publish, bulk generation, HowTo and ItemList schema and custom post types, at $49 once for one site or $99 once for up to 100 sites, with lifetime updates and a 14-day money-back guarantee.

## Before you add another schema type

Run the type count on your three best pages.

If it comes back with seven or eight types, the question is not which type to add next. Which of them is your page actually about, and what are the other six telling an agent that you never meant to say?