Speakable schema is the only structured data type that explicitly tells AI systems which sections of a page are suitable for text-to-speech reading. Every other schema type describes what a page is or what it contains. Speakable schema points to specific CSS selectors on the page and says: these sections are ready to be spoken aloud.
Google Assistant uses Speakable schema for news and information content. As voice search expands to cover more content types, and as AI Mode increasingly serves answers through voice interfaces, Speakable schema's role is expanding beyond the audio news reading use case where it was originally deployed.
Most AEO practitioners implement FAQPage, Article, and Organisation schema and skip Speakable entirely — because it is not covered in most schema tutorials and because it has a slightly different implementation pattern from the JSON-LD types most teams are familiar with. This guide covers the complete implementation.
What Is Speakable Schema and How Does It Work?
Speakable schema is a schema.org property that can be added to Article, WebPage, and WebSite schema types. It uses a SpeakableSpecification object to identify which parts of the page content are appropriate for audio playback.
Two specification methods are supported: CSS selector-based and XPath-based. CSS selectors are easier to implement for most developers and produce cleaner, more maintainable markup. XPath is available for more complex selector requirements.
When Google Assistant processes a page with Speakable schema, it reads the specified sections rather than trying to infer which passages are best suited for audio from the full page content. Without Speakable schema, Google Assistant chooses passages based on its own extraction logic — which may pick your table of contents, your meta description, or a navigation element instead of your answer blocks.
Speakable schema removes that uncertainty. You define the answer blocks. The voice assistant reads them.
How Do You Implement Speakable Schema With CSS Selectors?
The CSS selector method references specific HTML classes or element patterns in your page. Implementation requires two steps: marking up your HTML with consistent CSS classes on answer blocks, and adding the Speakable JSON-LD referencing those classes.
Step 1: Add CSS classes to your answer blocks. Every section that should be speakable needs a consistent CSS class. In your HTML:
<h2>What Is Speakable Schema?</h2>
<p class="answer-block">
Speakable schema is a structured data property that tells AI voice
assistants which sections of a webpage to read aloud. It uses CSS
selectors to point to answer blocks, removing ambiguity from
voice passage extraction.
</p>The class name (answer-block) is arbitrary — use whatever is consistent across your CMS. The important thing is that every passage you want spoken has the same class applied.
Step 2: Add Speakable JSON-LD to your page head.
{
"@context": "https://schema.org/",
"@type": "WebPage",
"name": "Speakable Schema: The Complete Implementation Guide",
"speakable": {
"@type": "SpeakableSpecification",
"cssSelector": [
".answer-block",
"h2 + p",
".callout p"
]
},
"url": "https://notioncue.com/blog/speakable-schema-complete-implementation-guide"
}The cssSelector array accepts multiple selectors. h2 + p selects the first paragraph immediately following any H2 heading — a reliable selector for BLUF-structured content where every H2 section opens with a direct answer paragraph. .callout p selects callout boxes, which typically contain highlighted answers. .answer-block selects explicitly marked answer passages.
How Do You Implement Speakable Schema With XPath?
XPath is useful when CSS selectors cannot reliably target the right elements — for example, when your CMS generates inconsistent HTML that cannot be reliably selected by class or element adjacency.
{
"@context": "https://schema.org/",
"@type": "WebPage",
"speakable": {
"@type": "SpeakableSpecification",
"xpath": [
"/html/head/title",
"/html/body//article//p[1]",
"/html/body//section[@class='answer']//p"
]
},
"url": "https://notioncue.com/blog/speakable-schema-complete-implementation-guide"
}XPath targets are evaluated at runtime against the page DOM. /html/body//article//p[1] selects the first paragraph inside every article element in the body — which for BLUF-structured content targets the direct answer paragraph at the top of each article section.
What Content Should Be Marked as Speakable?
Four content types should be marked speakable. Two content types should not.
Mark speakable: Direct answer paragraphs under H2 headings. The first paragraph of each section — the BLUF answer block — is the ideal speakable content. It is self-contained, under 100 words, and directly answers the heading question. Exactly what a voice assistant needs.
Mark speakable: FAQ answer text. Each acceptedAnswer.text in your FAQPage schema is already structured as a spoken answer. Apply speakable selectors to the FAQ answer elements so they are available for both FAQPage extraction and direct voice reading.
Mark speakable: Callout and summary boxes. These highlight key facts, statistics, or conclusions. They are typically concise, complete, and written for quick consumption — all characteristics that make them excellent voice passages.
Mark speakable: Page title and first paragraph. Google's own documentation recommends including the article title and summary paragraph as speakable. These give voice assistants context before reading a more detailed section.
Do not mark speakable: Tables and bullet lists. Tables read nonsensically when spoken aloud. Lists of bullets without prose context are confusing as audio. Exclude any element containing a table, list, or visual comparison from your speakable selectors.
Do not mark speakable: Navigational and meta elements. Page menus, breadcrumbs, footer content, and sidebar elements are not informational content and should be excluded. Make your CSS selectors specific enough to avoid accidentally targeting navigational elements with p or div selectors.
How Does Speakable Schema Relate to Other Schema Types?
Speakable schema works alongside, not instead of, other schema types. The full schema stack for a content page optimised for both AI citation and voice search:
- Article schema — classifies the page as editorial content with named authorship and dateModified. See the complete schema guide for implementation.
- FAQPage schema — provides machine-readable Q&A pairs for direct AI extraction and voice assistant use.
- Speakable schema — points voice assistants to the prose answer blocks between the FAQ items.
- BreadcrumbList schema — provides topical hierarchy context.
- Organisation schema — entity identity for the brand behind the content.
These five types together create a page that is retrievable by AI text search, extractable at the passage level, machine-readable for Q&A, voice-ready for audio delivery, and entity-identified for knowledge graph confidence. No single type does all of this alone.
How Do You Test Whether Speakable Schema Is Implemented Correctly?
Three validation steps:
Google Rich Results Test. Visit search.google.com/test/rich-results and enter your page URL. The tool will confirm whether your Speakable schema is valid JSON-LD and whether the referenced CSS selectors resolve to actual page elements. An "invalid" result typically means either the JSON-LD is malformed or the CSS selectors do not match any elements on the page.
Schema.org validator. Visit validator.schema.org and paste your Speakable JSON-LD. This confirms the schema structure is valid against schema.org specifications independently of whether it targets the right page elements.
Manual Google Assistant test. Ask Google Assistant a question that matches one of your page's H2 headings. If the assistant reads back content from your speakable sections, the implementation is working. If it reads something else — or does not cite your page at all — either the selectors are not hitting the right elements or the page is not indexed for that query.
Speakable schema only works if Google's crawler can reach and parse your page to apply the selectors. The NotionCue AI Crawler Audit confirms Googlebot is fetching your pages fully and that critical content is present in the initial HTML response. Speakable selectors applied to JavaScript-rendered content that is invisible in the initial HTML have no effect — the crawler never sees the elements the selectors point to.
Frequently Asked Questions
Does Speakable schema affect regular text search rankings?
Not directly. Speakable schema is processed by the voice assistant layer, not the ranking algorithm. However, the content quality required for speakable passages — direct answer sentences under 30 words, self-contained meaning, answer-first structure — correlates with better featured snippet performance and AI Overview citation rates. The discipline of marking content speakable forces better BLUF structure throughout.
Which pages should get Speakable schema first?
Your highest-traffic informational and FAQ pages. These are the pages most likely to match voice queries and the ones where you already have the BLUF-structured answer content that makes speakable passages work. Product pages and ecommerce category pages come second, because voice commerce queries are growing rapidly. About and contact pages are lower priority.
Is Speakable schema supported by all voice assistants?
Google explicitly supports it for Google Assistant. Alexa and Siri do not use Speakable schema directly — they rely on their own passage extraction from Bing and Apple indexes respectively. For maximum voice search coverage, combine Speakable schema (for Google Assistant) with Bing Webmaster Tools indexation (for Alexa eligibility) and Apple-friendly content structure (clean HTML, no JavaScript-dependent content, fast load times for Siri).
Can Speakable schema be added to existing WordPress or Shopify sites?
Yes. On WordPress, Speakable schema can be added through existing schema plugins (Yoast SEO Premium, Rank Math) or custom JSON-LD blocks. The CSS selector approach requires consistent class names on answer paragraphs, which may need a theme update if answer blocks do not already have unique classes. On Shopify, Speakable can be added to theme templates via the schema.org JSON-LD block in the page header. Test with Rich Results Test after implementation to confirm selectors resolve correctly.