DiscussionForumPosting Schema

TL;DR — DiscussionForumPosting schemaDiscussionForumPosting schema (schema.org/DiscussionForumPosting) is structured data for genuinely user-generated forum and community posts, so Google can identify online discussions and consider them for the Discussions and forums and Perspectives features. It requires author, datePublished, and one of text/image/video. is code you add to forum and community posts written by your users that labels who wrote each post, when, and what it says — so Google can tell it’s an online discussion and maybe show it in the Discussions and forums section of search results. It only works for genuinely user-generated content — not your own articles, and not product reviews. And if your forum is really a question with answers, Google wants you to use Q&A markup instead.

What DiscussionForumPosting schema is

When people post and reply on a forum, you can read who said what and when just by looking at the page. A search engine sees plain text and has to guess which part is the original post, which parts are replies, and who wrote each one. DiscussionForumPosting schema spells that out in code, using the shared vocabulary from schema.org, so Google can understand that a page is an online discussion.

Google added support for it in November 2023 to power a search feature you’ve probably seen — the “Discussions and forums” block that shows forum threads and community answers in results — and a related experience called Perspectives that highlights first-hand takes from real people.

What Google needs at minimum

For each post (and each reply, marked up as a Comment), you need:

• author — who wrote it, with their name.
• datePublished — when it was posted.
• one of text, image, or video — the actual content of the post.

That’s the floor. There are lots of optional extras — a comment count, likes and views, edit dates — but those three are what make it valid.

The thing most people get wrong

This is only for content your users wrote. Google is explicit: don’t use it for articles or blog posts your site authored (even ones with a comment section), and don’t use it for product reviews. It’s for real forum and community discussion.

Two more beginner traps:

• If your forum is a question followed by answers, use Q&A markup, not this. Google gives a clear rule: question-and-answer structure → Q&A markup; general discussion → DiscussionForumPosting.
• Markup doesn’t guarantee anything shows up. It makes your content eligible to appear in Discussions and forums — Google still decides whether to actually show it.

There’s also one genuinely surprising rule that trips up experienced developers: for this schema type, Google actually recommends an older markup format (Microdata) over the JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. most people default to. More on why in the Advanced tab, along with the AI-content disclosure property, how to mark up threaded replies, and the honest 2026 question of whether this is still worth doing.

TL;DR — DiscussionForumPosting (schema.org/DiscussionForumPosting, a subtype of SocialMediaPosting) marks up genuinely user-generated forum posts so Google can identify online discussions and consider them for Discussions and forums and Perspectives. Google launched it on Nov 27, 2023 alongside ProfilePage. Required on both the post and every nested Comment: author, author.name, datePublished, and one of text/image/video. Two real outliers: Google recommends Microdata/RDFa over JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. for this type specifically (to avoid duplicating large text blocks), and it’s strictly for user-generated content — not site-authored articles or product reviews. Q&A-structured forums should use Q&A markup instead. digitalSourceType discloses AI vs. human content; if omitted, Google assumes human-generated. Markup = eligibility, never guaranteed appearance. Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. added a dedicated Discussion Forum performance filter on July 8, 2025. Bing has no dedicated guidance for this type. And the honest 2026 question is whether the implementation cost is justified by your forum’s actual search visibility; markup alone cannot answer that.

My general stance on schema hasn’t changed: I’m a fan of markup as long as it earns you a genuine search feature. DiscussionForumPosting is an interesting case because it does map to a real feature (Discussions and forums), but it lands in a year where the underlying content type — user-generated forum content — is under visible pressure in Google’s rankings. So this is worth doing precisely, and worth being honest about what it does and doesn’t buy you.

What it is, and why Google built it

Google announced support on Monday, November 27, 2023, in a Search Central blog post by Thomas Han. It launched two types at once — DiscussionForumPosting and its companion ProfilePage — both designed, in Google’s words, to work with “Google Search features that are designed to show first-person perspectives from social media platforms, forums, and other communities.” The point was to help Google “better identify forum sites and online discussions across the web” and feed the Perspectives and “Discussions and forums” features.

The type sits at schema.org/DiscussionForumPosting, with the hierarchy Thing > CreativeWork > Article > SocialMediaPosting > DiscussionForumPosting. If your site is more of a generic social platform than a forum, Google says the direct parent — SocialMediaPosting — can be used instead, with the same requirements.

Required properties

Google’s discussion forum structured-data documentation requires the same small set on both the top-level DiscussionForumPosting and each nested Comment:

• author (Person or Organization) — information about who wrote the post. Google recommends following its author markup best practices so it can understand authors across features.
• author.name (Text) — the author’s name.
• datePublished (DateTime) — when the post was made, in ISO 8601.
• One of text, image, or video — to represent the content of the post. The one exception: you can skip this if you’re representing a post that lives on another page via an external url (as on later pages of a paginated thread or on category pages).

Requirements by context

The floor above isn’t one flat checklist — it changes slightly depending on what you’re marking up and where:

The exception in that third row is narrow: it applies to representing a post on another page, not to skipping content on the post’s own canonical page. Don’t generalize it into “text is optional” — on the page that’s actually the post’s home, you still need one of text, image, or video.

A minimal, valid JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. example — even though, as I’ll get to, Google would rather you used Microdata here:

{
  "@context": "https://schema.org/",
  "@type": "DiscussionForumPosting",
  "headline": "How do you verify Googlebot without an IP list?",
  "author": {
    "@type": "Person",
    "name": "haecceity123",
    "url": "https://forum.example.com/users/haecceity123"
  },
  "datePublished": "2026-06-30T09:12:00-05:00",
  "text": "The full text of the original post, exactly as it appears on the page…",
  "comment": {
    "@type": "Comment",
    "author": { "@type": "Person", "name": "seonerd" },
    "datePublished": "2026-06-30T10:04:00-05:00",
    "text": "The full text of the reply, exactly as it appears on the page…"
  }
}

Recommended properties that add real value

Eligibility comes from the required set, but the richness comes from the recommended one:

• comment (Comment) — a response to the post. Mark up comments in the order they appear on the page.
• commentCount (Integer) — especially useful when not every comment is present in the markup.
• interactionStatistic (InteractionCounter) — Google supports LikeAction (upvotes), DislikeAction (downvotes), ViewAction (views), CommentAction / ReplyAction (reply count), and ShareAction (reshares). This is how you surface the engagement signals that make forum threads look alive.
• dateModified (DateTime) — the edit timestamp. Google says if nothing has changed, there’s no need to duplicate the publish date here.
• creativeWorkStatus (Text) — set to Deleted when a post has been removed but is kept for threading/context.
• headline (Text) — the post title. Google’s guidance: if there isn’t a separate title, don’t duplicate or truncate the text into a headline — it says that’s not recommended for a SocialMediaPosting.
• image / video — inline media only. Explicitly: if there aren’t any images, don’t stuff default, icon, placeholder, or author avatars into the image field.
• isPartOf (CreativeWork or URL) — the subforum or group the post belongs to.
• sharedContent (a CreativeWork subtype) — the primary shared, linked, or quoted content (a WebPage, ImageObject, VideoObject, or a referenced DiscussionForumPosting / Comment for quoted/reposted content).
• author.url — a link to the author’s profile page. Google recommends marking that page up with ProfilePage structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. — the companion type from the same launch.
• url (URL) — the canonical URLHow search engines pick one canonical URL among duplicates and consolidate signals onto it.. In multi-page threads, set this to the first page’s URL.

Don’t try to mark up the entire schema.org spec

Because DiscussionForumPosting inherits from Article and CreativeWork, the schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. spec technically allows dozens of properties Google neither documents nor uses — articleBody, wordCount, license, copyrightHolder, aggregateRating, and so on. Follow Google’s required-plus-recommended subset for SEO purposes, not the full schema.org property list. Marking up more doesn’t earn you anything here.

The digitalSourceType property: disclosing AI vs. human content

This one is newer and, I think, the property most likely to matter more over time, not less. digitalSourceType (an IPTCDigitalSourceEnumeration) is “particularly relevant for distinguishing between human and AI or other machine-generated content.” Google supports:

• TrainedAlgorithmicMediaDigitalSource — content created by an LLMA large language model (LLM) is a deep-learning model trained on massive text corpora to predict the next token and generate human-like text. LLMs use the transformer architecture and power AI search features like Google's AI Overviews (Gemini) and Bing Copilot (GPT-4)..
• AlgorithmicMediaDigitalSource — content from a simpler botA crawler — also called a spider or bot — is an automated program that fetches web pages, extracts their links, and queues new URLs to visit. Search engines use crawlers to discover and download content for their index. or automated reply.

The default is the important part: “If this property is not specified, Google will assume the content is human-generated.” That’s what Google documents: the default assumption and the two supported algorithmic values. It doesn’t spell out what happens beyond that — no stated moderation policy, ranking effect, or enforcement consequence for omitting it. My own read, not Google’s: as machine-authored forum content becomes more common, disclosing it here is the honest move regardless of whether Google currently does anything with the signal. If your platform generates or allows machine-authored posts, this is the honest way to label them.

Threading and nesting: marking up replies correctly

Google gives explicit patterns, and getting the structure right is most of the job:

• Threaded (tree-structured) forums. Nest comments under the post they reply to. If the forum has its own threading structure, mirror it with a tree of comments.
• Linear / flat forums. Nest all replies under the original post as comments. Ideally, later pages of a multi-page thread still include the original post with the main page URL.
• Multi-page threads. Set url to the first page’s URL, and use isPartOf to point at the subforum. On later pages, you can represent posts by external url (which is the case where the one-of-text/image/video requirement is waived).

mainEntity vs. mainEntityOfPage: single-post pages vs. list pages

For a page that’s primarily about one post (a thread’s own page), use mainEntity (or mainEntityOfPage) to identify the primary DiscussionForumPosting. Google’s explicit warning: don’t mark one post as the main entity if the page isn’t actually a discussion page for that post. For list, category, or profile pages that show many posts, attach them to a Collection or ItemList instead — not a single main entity.

Why Google recommends Microdata/RDFa over JSON-LD here

This is the genuine outlier, and it catches experienced people out. For almost every other structured-data type, Google’s stated preference is JSON-LD. For this one, it says the opposite: “Unlike our general structured data preference, we recommend providing the DiscussionForumPosting markup in Microdata (or RDFa) if possible. This prevents you from needing to duplicate large text blocks inside markup. However, this is just a recommendation, and JSON-LD is still fully supported.”

The reasoning is practical: JSON-LD lives in a separate script block, so all that post and comment text has to be duplicated — once in the visible HTML, once in the JSON. For a busy thread with hundreds of long comments, that’s a lot of repeated bytes. Microdata and RDFa annotate the existing HTML in place, so there’s no duplication.

Here’s my honest read: this is a legitimate, documented Google preference and worth knowing — but I’m not telling you to rip JSON-LD out of your site. This recommendation is scoped to this type, for the specific reason of text duplication, and Google is clear that JSON-LD is still fully supported. In practice, plenty of implementers ship this type as JSON-LD anyway because their platform already emits everything else that way, and it works. So: prefer Microdata/RDFa for large forum threads if you can do it cleanly; use JSON-LD if that’s what your stack does and the duplication isn’t a real problem. Don’t overreact to the outlier by changing your whole site’s approach.

Content eligibility: what counts as “genuinely user-generated”

This is the gate. Google: “Only use DiscussionForumPosting markup to describe a user-generated post on a website. Don’t use this markup for content that’s primarily authored by the publishers of the website or their agents.”

Valid use cases from the docs: a community forum where users talk about a game; a generic forum platform hosting varied subforum content; a social platform where users post and reply.

Invalid use cases, named explicitly: “An article or blog written directly by an agent for the website (even with comments)” and “User reviews about a product.” A blog post with a comment section is still a blog post — not a discussion forum. And product reviews belong in review markupReview schema (schema.org/Review) is structured data for a single critic's or user's evaluation of one specific thing — one author, one itemReviewed, one reviewRating — distinct from AggregateRating, which summarizes many reviews into an average., not here.

One more requirement people skip: completeness. Google wants “the entire text of the post” and “the entire text of the response” for each comment present on the page — not a summary or a truncation.

Distinguishing it from QAPage and FAQPage

Three sibling types get confused constantly, and the decision matters:

• DiscussionForumPosting — general, open-ended forum and community discussion. No single “correct” answer structure.
• QAPage — for pages built around a question with user-submitted answers (think a Stack Overflow-style thread). Google’s decision rule is direct: if your forum is structured by a question followed by answers, use Q&A markup instead. Google actually updated its Q&A documentation at the same time it launched this type, specifically to align the two.
• FAQPage — for a list of questions and answers about a single entity, authored by the site itself (an official FAQ), not user discussion.

The one-line version: user discussion → DiscussionForumPosting; user Q&A → QAPage; your own official FAQ → FAQPage. And don’t stack DiscussionForumPosting and QAPage on the same page. The Decision Trees tab walks a mixed-forum case where different subforums call for different types.

Perspectives, Discussions and forums — and “considered for,” not guaranteed

Here’s the expectation-setting that matters most. From the launch post: “Forums with this markup are considered for having their content appear in the Perspective and ‘Discussions and forums’ features. However, the use of the markup does not guarantee appearance.”

Read that literally. Correct, complete markup makes your content eligible — it’s in the running for those features. It does not force inclusion, and it is not a ranking signal for ordinary web results. If someone sells you on “add this schema and your forum will show up in Discussions and forums,” that’s the myth Google’s own wording rules out.

Measuring it: the Search Console filter

The most concrete, measurable payoff arrived on July 8, 2025, when Search ConsoleGoogle's free tool for monitoring crawling, indexing, and search performance. added “Discussion Forum” as its own distinct search-appearance filter in the Performance reportThe Google Search Console report that shows how your site actually performed in Google Search, built from real impressions and clicks. It reports four metrics — clicks, impressions, average CTR, and average position — and keeps the most recent 16 months of data. — previously this content was lumped into generic rich-results/web buckets. As Search Engine Journal put it, the update “isn’t about new search capabilities, it’s about measurement.” Forum structured data had been supported for a while; now publishers finally have a way to monitor how that content actually performs.

Google also provides a Discussion forum rich-result report in Search Console (errors/warnings/valid items) and supports the type in the Rich ResultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show. Test and URL Inspection tool. If you’re implementing this, that Performance filter is the honest answer to “how will I know it did anything.”

Does Bing support this?

Short and honest: no dedicated Bing guidance exists for this type. Bing Webmaster Tools documents general structured-data support (JSON-LD, Microdata, RDFa, and more) via its Marking Up Your Site with Structured Data help page and its Markup Validator, and Bing doesn’t prefer one format over another. But there’s no Bing help article, blog post, or announcement that names DiscussionForumPosting or a “Discussions and forums”-equivalent feature. Bing will parse valid markup without erroring — there’s just no Bing rich-result surface built around this type the way Google built one. Don’t assume parity; this is a Google-only feature today.

Is it still worth doing in 2026?

I want to be straight with you here, because almost nobody writing about this schema type engages with the elephant in the room: user-generated and forum content has been losing search visibility in Google’s 2025–2026 core updates. In Amsive’s analysis of the March 2026 core update, Lily Ray’s team documented that Reddit, Instagram, and X — the platforms that drove the UGC and social explosion in the SERPs from roughly 2023 through 2025 — all posted significant losses with that update, and that Quora and other Q&A/forum platforms declined after a couple of years of steady growth. (I’m relaying that finding rather than quoting it word-for-word; read the source for the exact figures.)

So does implementing DiscussionForumPosting still matter if Google is simultaneously de-prioritizing UGC visibility broadly? My honest take:

• The markup is not why UGC is losing ground, and it won’t reverse it. Core-update visibility shifts are about content quality, helpfulness, and Google’s evolving weighting of source types — not whether you added the right schema. Don’t expect this markup to fight a core update.
• But the measurable payoff is real and separable. The Search Console Discussion Forum performance filter gives you actual measurement of how your forum content performs, independent of whether the Discussions and forums feature includes you. That’s worth having if you run a genuine community.
• Structured data still helps machines parse your content’s structure — that’s a mechanical benefit independent of whether any one search or AI feature ends up using it. Clean, honest markup (with digitalSourceType where relevant) is table stakes for being machine-readable, even in a tougher visibility climate. I don’t have evidence that this specific schema type feeds AI answer engines or citation systems — treat that as a plausible adjacent benefit, not a documented one.

Net: if you run a genuine user-generated community, mark it up correctly — it’s cheap, it’s honest, and it earns you real measurement. Just don’t sell it internally as a traffic lever that will beat the broader UGC pullback, because it won’t.

Where this sits

DiscussionForumPosting is one type in the broader structured data family this article lives under, alongside the commerce-focused Product schemaProduct schema (schema.org/Product) is structured data that tells search engines a page's product name, price, availability, and reviews so it can appear in Shopping-style rich results. It's separate from a Google Merchant Center feed, though Google reconciles the two., ProductGroup schema, and JobPosting schemaJobPosting schema is the schema.org/JSON-LD vocabulary you add to a single job-listing page so Google (and Bing) can read the role, employer, location, salary, and dates — making the page eligible for Google for Jobs. It requires title, description, datePosted, hiringOrganization, and jobLocation (or applicantLocationRequirements for fully remote roles). work, and the neighboring QAPage and FAQPage types it’s most often confused with. The same discipline applies to all of them: use the type that maps to a confirmed feature, keep the markup in parity with the visible page content, use only genuinely applicable properties, and validate before you ship. Its companion ProfilePage (from the same 2023 launch) is the natural partner — it’s the recommended target for author.url.

AI summary

A condensed take on the Advanced version:

• What it is: DiscussionForumPosting (schema.org/DiscussionForumPosting, a subtype of SocialMediaPosting) marks up genuinely user-generated forum posts so Google can identify online discussions and consider them for Discussions and forums and Perspectives.
• Launch: Nov 27, 2023, via a Search Central post by Thomas Han, alongside the companion ProfilePage type.
• Required (on the post AND every nested Comment): author, author.name, datePublished, and one of text/image/video. (The one-of media requirement is waived when a post is represented by an external url.)
• Recommended: comment, commentCount, interactionStatistic (likes/views/ replies/shares), dateModified, creativeWorkStatus (Deleted), headline, image/video, isPartOf, sharedContent, author.url (point it at a ProfilePage), url.
• digitalSourceType: discloses AI vs. human content (TrainedAlgorithmicMediaDigitalSource for LLMA large language model (LLM) is a deep-learning model trained on massive text corpora to predict the next token and generate human-like text. LLMs use the transformer architecture and power AI search features like Google's AI Overviews (Gemini) and Bing Copilot (GPT-4). output, AlgorithmicMediaDigitalSource for simpler botsA crawler — also called a spider or bot — is an automated program that fetches web pages, extracts their links, and queues new URLs to visit. Search engines use crawlers to discover and download content for their index.). If omitted, Google assumes human-generated.
• Format outlier: Google recommends Microdata/RDFa over JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. for this type, to avoid duplicating large text blocks — the opposite of its usual JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. preference. JSON-LD is still fully supported, and many implementers use it anyway; don’t change your whole site over it.
• Eligibility gate: user-generated only. Invalid: site-authored articles/blogs (even with comments) and product reviews. Include the entire text of each post and comment.
• Sibling types: user discussion → DiscussionForumPosting; user Q&A → QAPage; your own official FAQ → FAQPage. Q&A-structured forums should use Q&A markup; don’t stack the two.
• Threading: nest comments under the post they reply to (tree for threaded, flat under the OP for linear); multi-page threads set url to the first page and use isPartOf. Use mainEntity/mainEntityOfPage for single-post pages; Collection/ ItemList for list/category pages.
• Markup ≠ guaranteed appearance: it makes content considered for the features, and it’s not a ranking signal.
• Measurement: Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. added a dedicated Discussion Forum performance filter on July 8, 2025 — the most concrete payoff.
• Bing: no dedicated support for this type; it parses valid markup but has no equivalent feature.
• 2026 reality: UGC/forum visibility has broadly pulled back in core updates (Reddit/Quora/etc., per Amsive/Lily Ray’s March 2026 analysis). The markup won’t reverse that, but the measurement and machine-readability payoff is real for genuine communities.

Official documentation

Primary-source documentation and the launch announcement.

Google

• Discussion forum (DiscussionForumPosting) structured data — the required/recommended properties, threading patterns, content eligibility, the Microdata/RDFa recommendation, and the digitalSourceType property.
• New in structured data: discussion forum and profile page markup — the Nov 27, 2023 launch post (Thomas Han), covering the Perspectives / Discussions and forums tie-in and the Q&A-vs-forum decision rule.
• Profile page (ProfilePage) structured data — the companion type, recommended target for author.url.
• Rich Results Test — validate the markup and check eligibility.
• Schema Markup Validator — validate the schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. syntax of any type.
• schema.org — DiscussionForumPosting — the vocabulary reference, including a real Reddit thread used as the canonical example.

Bing / Microsoft

• Marking Up Your Site with Structured Data — Bing’s general structured-data support (JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal., Microdata, RDFa).

Quotes from the source

On-the-record statements from Google’s documentation and launch announcement. Each link is a deep link that jumps to the quoted passage on the source page.

Google launch post — what it’s for (Thomas Han, Nov 27, 2023)

• “Today we’re announcing support for profile page and discussion forum structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. for use in Google Search, including new reports in Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results..” Jump to quote
• “Forums with this markup are considered for having their content appear in the Perspective and ‘Discussions and forums’ features. However, the use of the markup does not guarantee appearance.” Jump to quote

Google docs — purpose and required content

• “Discussion forum markup is designed for any forum-style site where people collectively share first-hand perspectives. When forum sites add this markup, Google Search can better identify online discussions across the web and make use of this markup in features such as Discussions and Forums.” Jump to quote
• On the media requirement: “This is not required if you are representing a post on another page (with an external url) as in later pages of forums or forum category pages.” Jump to quote

Google docs — the Microdata/RDFa outlier

• “Unlike our general structured data preference, we recommend providing the DiscussionForumPosting markup in Microdata (or RDFa) if possible.” Jump to quote

Google docs — content eligibility and AI disclosure

• “Only use DiscussionForumPosting markup to describe a user-generated post on a website.” Jump to quote
• On digitalSourceType: “If this property is not specified, Google will assume the content is human-generated.” Jump to quote
• On author markup: “Information about the author of the post. To help Google best understand authors across various features, we recommend following the author markup best practices.” Jump to quote

Paraphrased — sourced secondhand, not quoted verbatim

• On the July 2025 Search ConsoleGoogle's free tool for monitoring crawling, indexing, and search performance. filter and the 2025–2026 UGC pullback: both the exact Search Console changelog wording and the Amsive/Lily Ray March 2026 core-update figures are relayed from secondary coverage in my research, so I’ve paraphrased them in the Advanced tab rather than quoting. Confirm exact wording against the primary sources (the live Search Console changelog and the Amsive article) before treating them as direct quotes.

Which schema does my community content need?

The most common real question with forum markup isn’t how to implement it — it’s which type to use. Click through it.

Myths and mistakes

The recurring ways forum markup goes wrong — and what’s actually true.

• Myth: “DiscussionForumPosting and QAPage are interchangeable — use whichever.” False. Google gives a content-structure decision rule: question-followed-by-answers → QAPage; general discussion → DiscussionForumPosting. And don’t use both on the same page.

• Myth: “This markup guarantees my forum will show in Discussions and forums or Perspectives.” False. Google’s own words: markup makes content “considered for” those features, and “the use of the markup does not guarantee appearance.” It’s an eligibility mechanism, not a ranking signal.

• Myth: “Use JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. like every other schema type — that’s Google’s preference.” Contradicted for this specific type. Google recommends Microdata or RDFa here, to avoid duplicating large text blocks. JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. remains fully supported, and plenty of implementers still use it — but don’t assume JSON-LD is the recommended default here the way it is elsewhere.

• Myth: “It works for blog comments or product reviews with a comment section.” Explicitly invalid. “An article or blog written directly by an agent for the website (even with comments)” and “User reviews about a product” are both named invalid use cases. This is strictly for genuinely user-generated forum/community posts.

• Myth: “Since it’s user-generated, content completeness doesn’t matter.” False. Google wants “the entire text of the post” and “the entire text of the response” for comments present on the page — not summaries or truncations.

• Myth: “Adding this schema is a ranking factor or a traffic guarantee for forum content.” Overstated. It’s an eligibility mechanism for specific features and the Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. performance filter — not a general ranking signal. And 2025–2026 core-update data shows forum/UGC content broadly losing SERP visibility regardless of markup.

• Myth: “I should mark up every schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. property the type page lists.” False. schema.org’s inherited property set (via Article/CreativeWork) is far larger than what Google documents and uses. Follow Google’s required-plus-recommended subset.

• Mistake: marking one post on a list/category page as the main entity. Use mainEntity/mainEntityOfPage only on a page that’s actually a discussion page for that post; for pages showing many posts, use a Collection or ItemList instead.

• Mistake: stuffing the image field with avatars or placeholders. If there aren’t real inline images, don’t include default, icon, placeholder, or author images.

• Mistake: not disclosing machine-generated content. If posts are AI- or botA crawler — also called a spider or bot — is an automated program that fetches web pages, extracts their links, and queues new URLs to visit. Search engines use crawlers to discover and download content for their index.-authored, set digitalSourceType — Google assumes human-generated when it’s omitted.

Worked examples

1. A clean threaded post (JSON-LD)

The required floor plus useful recommended properties — a top-level post with one nested reply, engagement stats, and a subforum reference. (Remember: for a large, comment-heavy thread, Google would rather you emit this as Microdata in the HTML to avoid duplicating all this text — but JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. is fully supported and is what most platforms ship.)

{
  "@context": "https://schema.org/",
  "@type": "DiscussionForumPosting",
  "mainEntityOfPage": "https://forum.example.com/t/verify-googlebot/12345",
  "headline": "How do you verify Googlebot without an IP list?",
  "url": "https://forum.example.com/t/verify-googlebot/12345",
  "datePublished": "2026-06-30T09:12:00-05:00",
  "author": {
    "@type": "Person",
    "name": "haecceity123",
    "url": "https://forum.example.com/u/haecceity123"
  },
  "text": "The full text of the original post, exactly as it appears on the page…",
  "isPartOf": {
    "@type": "CreativeWork",
    "name": "Technical SEO",
    "url": "https://forum.example.com/c/technical-seo"
  },
  "interactionStatistic": {
    "@type": "InteractionCounter",
    "interactionType": "https://schema.org/LikeAction",
    "userInteractionCount": 42
  },
  "comment": {
    "@type": "Comment",
    "author": { "@type": "Person", "name": "seonerd" },
    "datePublished": "2026-06-30T10:04:00-05:00",
    "text": "The full text of the reply, exactly as it appears on the page…"
  }
}

2. Disclosing an AI-generated reply

If a reply was written by an LLMA large language model (LLM) is a deep-learning model trained on massive text corpora to predict the next token and generate human-like text. LLMs use the transformer architecture and power AI search features like Google's AI Overviews (Gemini) and Bing Copilot (GPT-4). (say, an assistant botA crawler — also called a spider or bot — is an automated program that fetches web pages, extracts their links, and queues new URLs to visit. Search engines use crawlers to discover and download content for their index. in the thread), label it so Google doesn’t assume it’s human:

{
  "@type": "Comment",
  "author": { "@type": "Organization", "name": "Community Assistant" },
  "datePublished": "2026-06-30T10:20:00-05:00",
  "text": "The full text of the AI-generated reply…",
  "digitalSourceType": "https://schema.org/TrainedAlgorithmicMediaDigitalSource"
}

3. The wrong type on a Q&A page

Here’s the single most common mistake — a Stack Overflow-style page (a question followed by answers) marked up as a discussion forum:

{
  "@type": "DiscussionForumPosting",
  "headline": "Why is my canonical tag being ignored?",
  "text": "How do I…",
  "comment": [ { "@type": "Comment", "text": "You need to…" } ]
}

What’s wrong: this page is structured as a question with answers, so Google’s rule says use QAPage markup (with Question, acceptedAnswer, and suggestedAnswer) — not DiscussionForumPosting. Reserve DiscussionForumPosting for general, open-ended discussion threads.

4. Invalid: a site-authored blog with comments

{
  "@type": "DiscussionForumPosting",
  "headline": "Our 2026 guide to Core Web Vitals",
  "author": { "@type": "Organization", "name": "Example Inc" },
  "text": "In this guide we cover…",
  "comment": [ { "@type": "Comment", "author": { "@type": "Person", "name": "reader1" }, "text": "Great post!" } ]
}

What’s wrong: the post itself was authored by the site, not a user — that’s a named invalid use case (“an article or blog written directly by an agent for the website, even with comments”). Mark the article up as Article; the comment section alone doesn’t make it a discussion forum.

Test yourself: DiscussionForumPosting Schema

Five quick questions on DiscussionForumPosting structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding., its required properties, the format outlier, and how it differs from QAPage and FAQPage. Pick an answer for each, then check.

DiscussionForumPosting properties: required vs. recommended

Every property below applies on both the top-level DiscussionForumPosting and each nested Comment unless noted otherwise.

Which schema type: DiscussionForumPosting vs. QAPage vs. FAQPage vs. ProfilePage

Format note: for DiscussionForumPosting specifically, Google recommends Microdata or RDFa over JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. (to avoid duplicating large text blocks) — the opposite of its usual JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal.-first guidance. JSON-LD remains fully supported.

Tools for validating DiscussionForumPosting markup

My Schema Markup Validator is where I’d check the JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal., Microdata, or RDFa once you’ve written it. Paste the block (or a full page) and it runs severity-tiered checks against the DiscussionForumPosting vocabulary and Google’s structured-data requirements — it catches a missing author.name, a missing datePublished, or a post with none of text, image, or video present, and hands back a corrected, copy-pasteable block.

My Rich-Result Eligibility Checker answers a narrower question than plain validity: does this specific page qualify for Google’s Discussion forum treatment. Paste JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal., an HTML page, or fetch a live URL, and it shows which required fields are present on the top-level post and on each nested Comment versus which ones are missing.

If you’re building the markup from scratch rather than fixing an existing implementation, my Schema Markup Generator has a form for DiscussionForumPosting (plus every other schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. type, including ProfilePage for the companion author.url target) so you can fill in required and recommended properties without hand-writing the JSON-LD, and it flags whether each field is Google-required, Google-recommended, or schema.org-only as you go.

Once markup passes those checks, run the page through Google’s own Rich Results Test — it’s the tool Google actually uses to decide eligibility, so it’s the final word before you ship. For the underlying vocabulary itself, validator.schema.org checks schema.org syntax independent of any one search engine’s rules.

Resources worth your time

I don’t have a dedicated article on DiscussionForumPosting or forum schema — this is new ground for me rather than something I’ve written up before, so I’m not going to manufacture a citation. What carries over is my general schema stance: implement markup when it earns you a genuine search feature, keep it in parity with what’s visibly on the page, use only the properties that actually apply, and validate before you ship. There’s also a tangential connection to my work on link attributes — rel="ugc" tells Google how to treat links in user-generated content, which is a different job from DiscussionForumPosting telling Google what the content is.

My related schema writing (general, not forum-specific)

• What Is Schema Markup? How to Add It & Why It Matters (Ahrefs) — a general schema guide, including the AI-agent/machine-readability angle.
• Schema Markup for AISchema markup (structured data) is machine-readable code — usually JSON-LD — that labels what your content means using the schema.org vocabulary. For AI search it's infrastructure for entity disambiguation, not a direct citation lever: controlled studies found no meaningful uplift in AI citations from adding it. — the entity-infrastructure angle on schema (a different question from rich-result eligibility).
• The Beginner’s Guide to Technical SEO — where schema fits in the bigger picture.

From around the industry

• Discussion forum (DiscussionForumPosting) structured data (Google Search Central) — the authoritative reference for properties, threading, eligibility, and the Microdata recommendation.
• New in structured data: discussion forum and profile page markup (Google Search Central Blog) — Thomas Han’s Nov 2023 launch post with the Perspectives / Discussions and forums context and the Q&A-vs-forum rule.
• Google Adds Profile Page & Discussion Forum Structured Data With New Search Console Reports (Search Engine Roundtable) — Barry Schwartz’s launch-day recap.
• Google Search now supports discussion forum and profile page structured data (Search Engine Land) — launch coverage.
• Google Adds Forum Rich Results Reporting In Search Console (Search Engine Journal) — Matt G. Southern on the July 8, 2025 Performance-report filter.
• Google Search Console adds Discussion forums search appearance filter (Search Engine Land) — the same July 2025 measurement update.
• Google March 2026 Core Update: Winners, Losers & Analysis (Amsive / Lily Ray) — the UGC/forum visibility pullback context for the “is it still worth it” question (figures relayed; confirm against the source).

DiscussionForumPosting Schema

DiscussionForumPosting schema (schema.org/DiscussionForumPosting) is structured data for genuinely user-generated forum and community posts, so Google can identify online discussions and consider them for the Discussions and forums and Perspectives features. It requires author, datePublished, and one of text/image/video.

Related: Structured Data, FAQPage Schema, QAPage Schema

DiscussionForumPosting Schema

DiscussionForumPosting schema is the schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor./DiscussionForumPosting structured-data type — a subtype of SocialMediaPosting (under Article) — you add to user-generated forum and community posts so Google can identify them as online discussions. Google introduced support for it on November 27, 2023, alongside ProfilePage, tied to the Perspectives and “Discussions and forums” search features.

Every DiscussionForumPosting (and each nested Comment) requires author, author.name, datePublished, and at least one of text, image, or video. Recommended properties add value: comment, commentCount, interactionStatistic (likes/views/replies), dateModified, isPartOf, sharedContent, and digitalSourceType (which distinguishes human from AI or machine-generated content).

It’s strictly for genuinely user-generated content — not articles or blog posts authored by the site, and not product reviews. If a forum is structured as questions with answers, Google says to use Q&A markup instead; DiscussionForumPosting is for general discussion. Unusually for a schema type, Google recommends Microdata or RDFa over JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. here to avoid duplicating large text blocks — though JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. remains fully supported. Valid markup only makes content considered for the features; it never guarantees appearance.

Related: Structured Data, FAQPage Schema, QAPage Schema

Changelog