How to Create DiscussionForumPosting Schema

DiscussionForumPosting is the schema type most brands want and most brands do not qualify for, and knowing which side of that line you sit on is the whole first decision.

Google introduced forum-oriented result treatments because people started appending Reddit to their queries. The demand being served is for genuine first-hand perspective: somebody who actually owns the thing, actually did the job, actually had the problem. This type is the structured-data expression of that, and it only works if the content underneath it is real.

If you run a customer community, a public support forum, or a genuine question surface, this markup is available to you and almost nobody in your category is using it. If you run a blog with a comments section switched off, it is not, and applying it anyway is a spam signal rather than an opportunity.

What DiscussionForumPosting Is For

DiscussionForumPosting describes a single post in a discussion forum. Schema.org defines DiscussionForumPosting as a posting to a discussion forum, nested under SocialMediaPosting and above that Article.

Google maintains dedicated discussion forum structured data documentation covering how these pages become eligible for forum-oriented treatments in results.

The inheritance chain tells you how to think about it. Because it descends from Article, it expects the properties any article carries: an author, a publication date, a headline, body text. Because it is a SocialMediaPosting, it also expects the things a conversation has: replies, engagement counts, a thread structure.

That combination is the signal. An article has one voice and an authoritative tone. A forum post has an individual voice, a timestamp, a reply count, and other people disagreeing underneath it. The markup exists to tell a machine which of those it is looking at, because the retrieval value of the two is completely different.

Do You Actually Qualify?

Answer this honestly before writing any markup, because the failure mode here is worse than doing nothing.

You qualify if your page is a real discussion surface. A customer community where users post threads. A public support forum. A question board where anybody can ask and anybody can answer. A product review thread where the reviews are written by customers rather than staff. In all of these, the content is authored by people outside your organisation and the conversation is open-ended.

You do not qualify if the conversation is manufactured. A blog post with an FAQ styled to look like a Q and A. A landing page with testimonials laid out as a thread. A support article written by your team and presented as a community answer. An interview or roundup where your marketing department wrote both sides.

The reason this matters is that Google's helpful content guidance treats manufactured first-hand experience as a quality problem rather than a formatting one. Marking editorial content as a forum discussion is a misrepresentation of who wrote it, and the downside is not a validation warning, it is a trust problem across the domain.

The intermediate case is worth naming. If you run a community that is technically open but where 95 percent of posts are staff, you are closer to editorial than forum. The markup describes the surface, so the surface has to be genuinely participatory.

Required and Recommended Properties

The property set follows from the type's inheritance, and it splits into three groups.

The identity of the post is non-negotiable. Every posting needs an author, a datePublished, and either text or articleBody carrying the actual content. Without an author the markup is describing an anonymous document rather than a first-hand account, which defeats the point of the type.

The author is the property that carries the whole value. A forum post by Person with a name is a perspective. A forum post by Organization is a press release in a costume. If your community has usernames, use them, and give the author a url pointing at the profile if profiles exist.

Engagement expresses whether the thread is alive. InteractionCounter is the type that carries counts, and it is used through interactionStatistic with an interactionType naming what is being counted. Reply counts, like counts, and view counts all fit here, and they are how a machine distinguishes a thread with 40 substantive replies from one with none.

Structure carries the conversation. comment holds the replies, commentCount states how many there are, and each reply is itself a Comment with its own author and date.

Two properties worth adding that most implementations skip. url on each posting gives the reply a stable address if your forum supports deep linking to individual comments. And upvoteCount on a Comment is the single most useful signal for identifying which reply the community considered correct, which is exactly what a retrieval system wants to know.

A Complete Working Example

Here is a full posting with two replies, one of which the community upvoted heavily.

{
  "@context": "https://schema.org",
  "@type": "DiscussionForumPosting",
  "@id": "https://example.com/community/thread/8842#post",
  "headline": "Cold brew keeps coming out sour on the 14 day old beans",
  "url": "https://example.com/community/thread/8842",
  "datePublished": "2026-07-14T09:12:00-04:00",
  "author": {
    "@type": "Person",
    "name": "mkirkland",
    "url": "https://example.com/community/users/mkirkland"
  },
  "text": "Been running an 18 hour cold steep at a 1:8 ratio with beans roasted two weeks ago. Consistently sour and thin. Same recipe on week old beans tastes fine. Grinder is a Baratza Encore on 28.",
  "interactionStatistic": [
    {
      "@type": "InteractionCounter",
      "interactionType": "https://schema.org/LikeAction",
      "userInteractionCount": 14
    },
    {
      "@type": "InteractionCounter",
      "interactionType": "https://schema.org/CommentAction",
      "userInteractionCount": 2
    }
  ],
  "commentCount": 2,
  "comment": [
    {
      "@type": "Comment",
      "@id": "https://example.com/community/thread/8842#c1",
      "author": {
        "@type": "Person",
        "name": "rosalind_b",
        "url": "https://example.com/community/users/rosalind_b"
      },
      "datePublished": "2026-07-14T11:40:00-04:00",
      "text": "Sour on older beans usually means under extraction rather than the roast date. At 18 hours and 1:8 you are probably fine on time, so grind finer before you change anything else. Try 22 on the Encore.",
      "upvoteCount": 31
    },
    {
      "@type": "Comment",
      "@id": "https://example.com/community/thread/8842#c2",
      "author": {
        "@type": "Person",
        "name": "devon_t",
        "url": "https://example.com/community/users/devon_t"
      },
      "datePublished": "2026-07-14T14:02:00-04:00",
      "text": "Water is worth checking too. If you are on soft filtered water the extraction drops off and it reads as sour. I add a mineral packet and the same recipe changes completely.",
      "upvoteCount": 6
    }
  ]
}

Three things that example does deliberately.

The content is specific. Ratios, timings, a named grinder, a setting number. A retrieval system extracting this gets something usable, which is why real forum content outperforms editorial content on these queries in the first place.

The upvote counts differentiate the replies. Thirty-one against six tells a machine which answer the community endorsed. Omit that and both replies look equally authoritative.

Every author is a Person with a profile URL. The perspective is attributable, which is the entire value proposition of the type.

Marking Up Replies

Two patterns exist and the right one depends on whether replies have their own URLs.

Nest the replies inside the parent posting when the thread lives on one page, which is the example above. This is the simpler and more common case, and it keeps the thread as a single retrievable unit.

Give each reply its own DiscussionForumPosting when replies are individually addressable, linking them to the parent. This suits large threads with pagination, where a single nested blob would be unmanageable and where individual replies genuinely deserve their own URL.

Two rules apply either way. Do not mark up a reply as a DiscussionForumPosting if it has no URL of its own, because you are asserting an address that does not exist. And keep the markup honest about what is on the page: if you paginate at 50 replies, the markup for page one describes those 50, not all 400.

Our post on forum SEO covers the strategic side of why these surfaces have become so influential.

DiscussionForumPosting Versus QAPage

These two types get confused constantly, and choosing wrong produces markup that describes the wrong thing.

QAPage is for a page whose primary content is one specific question with one or more answers. There is a question being asked, answers competing to resolve it, and often a marked accepted answer. Stack Overflow is the canonical shape.

DiscussionForumPosting is for an open-ended conversation. Somebody posts an experience, an opinion, or a problem, and the thread develops without necessarily resolving. There may be no question at all, and there is usually no accepted answer.

Apply the test by asking whether there is a single correct answer the thread is trying to reach.

• A user asks how to fix a specific error message and replies compete to solve it. That is QAPage.
• A user posts their setup and asks what people think. That is DiscussionForumPosting.
• A user reports that a product broke after six months and others share whether theirs did too. That is DiscussionForumPosting.
• A user asks which of two models to buy for a stated use case and replies argue for each. Genuinely borderline, and DiscussionForumPosting is the safer choice because the thread has no resolvable answer.

Our guide to QAPage schema covers the other side of the line in full.

Why This Matters for AI Citation

Forum content is disproportionately cited by AI engines, and the reason is a content property rather than a markup property.

A forum thread contains something editorial content usually lacks: multiple independent people reporting what actually happened, including the ones for whom it went badly. That is the closest thing on the open web to a controlled comparison, and it is why engines reach for it when a user wants to know whether a product works rather than what its features are.

Our post on how Reddit, YouTube and Wikipedia dominate AI citations covers the citation patterns in detail.

The markup helps in two specific ways. It identifies the content as first-hand perspective rather than editorial, which is the category engines are selecting for on these queries. And it exposes the internal ranking of the thread through upvote counts, which tells a retrieval system which reply to weight.

What the markup cannot do is manufacture the underlying value. A community with four posts marked up perfectly is still a community with four posts. The markup is worth adding once the surface is genuinely active, and the sequencing matters: build the community, then describe it.

Validation and Common Errors

Validate through Google's Rich Results Test and the Schema.org validator, since they catch different classes of problem. The Rich Results Test tells you about Google eligibility, and the Schema.org validator catches type and property errors Google may silently tolerate.

Six errors account for most failures.

• Author as Organization on a user post. This contradicts the whole purpose of the type. If a staff member posted, name the person.
• Missing datePublished. Recency is load-bearing on discussion content and its absence removes a signal you want.
• commentCount disagreeing with the comment array. Google compares them. If you paginate, the count should reflect what is on the page.
• Marking editorial content as forum content. The largest risk in this whole area, and it is a trust problem rather than a validation one.
• Empty interactionStatistic blocks. A counter of zero is worse than no counter, because it advertises a dead thread.
• Markup describing content hidden behind a login. If a crawler cannot see the replies, do not claim them. Google needs to verify the markup against visible content.

Our guide to schema markup for AI search covers which types earn citations more broadly.

Frequently Asked Questions

Can I use DiscussionForumPosting on a blog with comments?

Only if the comments are the primary content of the page. A blog post is an Article or BlogPosting with a comment thread attached, so mark it as that and use the comment property. Reclassifying the page as a forum posting misdescribes what it is.

Does DiscussionForumPosting guarantee a forum rich result?

No. Structured data makes a page eligible for a treatment, and Google decides whether to show it. The markup improves your odds and makes the content machine-legible, which is worth having regardless of whether a visual treatment appears.

What is the difference between DiscussionForumPosting and QAPage?

QAPage is for one specific question with competing answers and often an accepted answer. DiscussionForumPosting is for an open-ended conversation that may have no single correct resolution. If the thread is trying to reach one right answer, use QAPage.

Should I mark up every reply individually?

Only when replies have their own URLs. On a single-page thread, nest them as Comment objects inside the parent posting. Giving a reply its own posting type while it has no address of its own asserts something untrue.

Will this help my brand get cited by AI engines?

It helps engines identify your community content as first-hand perspective, which is the category they favour on experience-based queries. It cannot substitute for an active community. The markup describes value, it does not create it.