Polymarket Comments API (2026): Read Market Comments in Code

How do you get comments for a Polymarket market?

Comments attach to events and series, not to individual markets. Pass the event id as the parent:

curl -s "https://gamma-api.polymarket.com/comments?parent_entity_type=Event&parent_entity_id=45915&limit=20&order=createdAt&ascending=false"

The response is a plain array. A top-level comment and its first reply look like this, trimmed:

[
  {
    "id": "3279728",
    "body": "...",
    "parentEntityType": "Event",
    "parentEntityID": 45915,
    "userAddress": "0x...",
    "createdAt": "2026-10-02T18:47:11.434762Z",
    "reactionCount": 0,
    "reportCount": 0,
    "profile": { "name": "...", "pseudonym": "...", "proxyWallet": "0x...", "baseAddress": "0x..." }
  },
  {
    "id": "3279740",
    "body": "...",
    "parentCommentID": "3279728",
    "replyAddress": "0x...",
    "createdAt": "2026-10-02T19:03:48.405527Z"
  }
]

What parameters does the comments endpoint take?

Without order, comments came back newest first in our checks. order=reactionCount&ascending=false surfaced the most-reacted comments instead, led by one with 70 reactions. Requests are limited to 200 per 10 seconds, and responses carried Cache-Control: public, max-age=90.

Why does an event return no comments?

Usually because it belongs to a series. Events in a series, such as each Fed decision or each month's Bitcoin price ladder, keep their comments on the series. In our checks, the October 2026 Fed decision event returned an empty array as an Event and showed a commentCount of 0, while its FOMC series, id 35, held 9,601 comments. The same held for a monthly Bitcoin series and a Dota 2 series.

The fix is to read the event first. When its series array has an entry, query parent_entity_type=Series with that series id. Each series entry also carries its own commentCount, so you know what to expect before paging.

How do threads and replies work?

Threads are one level deep. A reply carries parentCommentID, pointing at a top-level comment, and in a sample of 104 replies none pointed at another reply. replyAddress names the person being answered: it matched the top-level author in 72 of those replies, and most of the rest pointed at another person in the same thread.

Each reply sits directly after its parent in the array, oldest first, and limit counts only top-level comments. Asking for 100 returned 204 rows: 100 top-level comments and 104 replies. GET /comments/{id} returns the whole thread, parent and replies, whether you pass the parent's id or a reply's.

That ordering has a catch for anyone polling. Threads sort by the top-level comment's time, so a new reply to an older thread lands on a later page. In our checks, pages 2 and 3 held replies posted after the oldest thread on page 1. Re-read the threads you care about by id instead of relying on the first page.

How do you read commenter profiles and positions?

Every comment embeds a profile with name, pseudonym, displayUsernamePublic, bio, proxyWallet, baseAddress and profileImage. Two addresses are in play. The comment's userAddress equaled profile.baseAddress in all 204 rows we checked and never the proxy wallet. GET /comments/user_address/{address} wants that base address too: for four of four users, the base address returned their comments and the proxy wallet returned an empty list.

The proxy wallet is the one the Data API uses for positions and trades, as explained in our Polymarket proxy wallet guide. Gamma's /public-profile?address= accepts either address and returns proxyWallet, createdAt and the display name.

With get_positions=true, profile.positions lists tokenId and positionSize. The size is in base units, so divide by 1,000,000: in five checks it matched the Data API's share count for the same wallet and token. This builds labeled threads for an event on Node 18 or newer:

const GAMMA = 'https://gamma-api.polymarket.com';

async function getJson(url) {
  const res = await fetch(url);
  if (!res.ok) throw new Error(`${url} returned ${res.status}`);
  return res.json();
}

async function commentThreads(eventSlug, limit = 20) {
  const event = await getJson(`${GAMMA}/events/slug/${eventSlug}`);
  const series = event.series?.[0];
  const parent = series ? { type: 'Series', id: series.id } : { type: 'Event', id: event.id };

  // Label each outcome token so a commenter's position reads as words.
  const tokenLabel = new Map();
  for (const market of event.markets ?? []) {
    const tokens = JSON.parse(market.clobTokenIds ?? '[]');
    const outcomes = JSON.parse(market.outcomes ?? '[]');
    tokens.forEach((token, i) => tokenLabel.set(token, `${market.groupItemTitle || market.question} ${outcomes[i]}`));
  }

  const url = new URL('/comments', GAMMA);
  url.searchParams.set('parent_entity_type', parent.type);
  url.searchParams.set('parent_entity_id', parent.id);
  url.searchParams.set('limit', String(limit));
  url.searchParams.set('order', 'createdAt');
  url.searchParams.set('ascending', 'false');
  url.searchParams.set('get_positions', 'true');
  const comments = await getJson(url);

  const threads = new Map();
  for (const c of comments) if (!c.parentCommentID) threads.set(c.id, { ...c, replies: [] });
  for (const c of comments) if (c.parentCommentID) threads.get(c.parentCommentID)?.replies.push(c);

  return [...threads.values()].map((t) => ({
    author: t.profile?.name || t.profile?.pseudonym || t.userAddress,
    holds: (t.profile?.positions ?? []).map(
      (p) => `${Math.round(Number(p.positionSize) / 1e6)} ${tokenLabel.get(p.tokenId) ?? 'other market'}`,
    ),
    text: t.body,
    reactions: t.reactionCount ?? 0,
    replies: t.replies.length,
  }));
}

console.log(await commentThreads('brazil-presidential-election', 10));

How do you read comments with Polymarket's SDK?

The unified TypeScript SDK wraps all three routes:

import { CommentParentEntityType, createPublicClient } from '@polymarket/client';

const client = createPublicClient();

const pages = client.listComments({
  parentEntityId: '45915',
  parentEntityType: CommentParentEntityType.Event,
  pageSize: 20,
  order: 'createdAt',
  ascending: false,
});

const page = await pages.firstPage();
for (const comment of page.items) {
  console.log(comment.id, comment.parentCommentID ?? 'top', comment.reactionCount, comment.body);
}

const thread = await client.fetchCommentsById({ id: page.items[0].id });
console.log(thread.length);

Is there a real-time Polymarket comments stream?

Not one to build on, as of October 2026. PolyBolt, the WebSocket that replaced RTDS for reference prices in September, has price channels only. When Polymarket moved prices off RTDS on 15 September, its changelog said "the comments topic stays on RTDS for now". That topic carried comment_created, comment_removed, reaction_created and reaction_removed events. Polymarket's real-time docs now say live comment and reaction streaming "is being retired without a replacement streaming channel", and SDK 0.11.0 marks its comments subscription as deprecated.

Poll instead. Request the newest page, keep the ids you have seen, and alert on the rest. Responses were cached for up to 90 seconds in our checks, so polling more often than about once a minute mostly returns the same page. For threads you follow, re-read GET /comments/{id} to pick up new replies.

How do you put comments next to live prices?

A comment reads differently next to the price it moved, or failed to move. Polymarket's market WebSocket streams prices for the tokens you subscribe to, as covered in our Polymarket WebSocket guide. The Predictefy API streams order books and trades from 15+ venues, Polymarket included, in one normalized format, so a comment feed can sit beside a live book wherever the same event trades.

Frequently Asked Questions