Reddit Comment IDs Are Now 13 Characters and Out of Order: What Breaks in Your Code

Reddit's comment IDs changed shape this week. New comments now get base-36 IDs up to 13 characters long, such as 19rlvtujyja1t, instead of the 7 or 8 characters developers have relied on for years, and Reddit no longer promises the IDs go up over time. If your code sorts, validates, stores or paginates by comment ID, check it now.

TL;DR: Reddit announced 13-character, non-monotonic comment IDs on r/redditdev for the week of 28 September 2026, and developers report every subreddit had them by 21 October. Old IDs keep their shape. Sort by created_utc, store IDs as text or BIGINT, keep them out of JavaScript numbers, and dedupe on the t1_ fullname.

This is an independent explainer from redditapis.com, a third-party API that is not affiliated with Reddit, Inc. The comment object itself, its fields and how to fetch a thread are in our Reddit API comments guide; the API access deadlines are in the October 31 cutoff post and the Developer Platform migration guide. This post covers one change: the comment ID format, what we measured in live data, and the fix for each place it breaks.

What changed about Reddit comment IDs?

Reddit's new comment IDs are still 64-bit integers written in base 36, but they are up to 13 characters long, 16 with the t1_ prefix, and they are no longer guaranteed to increase. Older comments keep their 7 or 8 character IDs. Post, user and subreddit IDs are not part of the change.

The specification is the same in both of Reddit's posts, the 11 May 2026 announcement and the 15 September 2026 reminder, both by the admin u/redtaboo on r/redditdev. Each opens with the same TL;DR:

The technical details, in Reddit's words:

• "New comment IDs will continue to be 64-bit integers and base36-encoded, but will not be monotonically increasing anymore."
• "The new base36-encoded comment IDs will be up to 13 characters long (e.g. 19gsnavtu46ip), compared to the current 7-8 characters."
• "With the t1_ prefix, the new base36-encoded comment IDs will be up to 16 characters long."
• "Older comment IDs are not changing, and referencing them will not break anything."

The example in Reddit's own post, 19gsnavtu46ip, decodes to 5,984,384,625,183,611,905. The old 7-character space tops out at 36 to the power of 7, which is 78,364,164,096, so the new IDs are roughly 76 million times larger than anything a 7-character ID could hold.

When did the new Reddit comment IDs go live?

Gradually, from early October to 21 October 2026. Reddit first set the week of 18 May, postponed it a day later, then set the week of 28 September. Developers on r/redditdev report the new IDs reached small subreddits first, about 30 percent of comments around 20 October, and all of them by 21 October.

The sequence, from Reddit's posts and the developer threads under them:

The May date did not hold. A day after the announcement, the same admin posted an update pushing the timeline back so Reddit could "better understand use cases where things may break completely". The update still told developers that "if all you need to do is fix your code to ensure it's not expecting a certain character count you should go ahead and do so".

The September reminder set the week of 28 September and added one line the May post did not have: "Pushshift has updated how they ingest data from Reddit and will continue to work after this change goes out." On 28 September a developer replied under it, "I still see old comment_id. When does the changes will roll out?"

The answer came on 22 October, when a developer noticed an AutoModerator notification carrying the ID 19rhzb7c1hvnp and asked when the change took effect:

Two replies in that thread give the best public timeline. The developer of RemindMeBot wrote that Reddit "rolled it out slowly over the last two weeks to small subreddits, then it jumped to about 30% two days ago, then to 100% yesterday". Another developer put the switch "at approximately 2026-10-21 13:23

What do the new comment IDs look like in live data?

Uniform. We read the newest 100 comments in each of five busy subreddits through our API on 24 October 2026: all 500 comment IDs were 13 characters, every one began with the same three characters, 19r, and all 500 parent posts still had 7-character IDs. Old and new formats still meet in replies.

We measured it through our own API:

Of the 500 newest comments we read across five busy subreddits, 100% carried a 13-character comment ID.

Our data · Dataset: newest-comment-ids-five-subreddits · Source: public Reddit posts, pulled through our API · Query: reddit_subreddit_comments {"limit": 100, "name": ["AskReddit", "worldnews", "gaming", "programming", "nba"]} · Pulled: 2026-10-24 · n = 500 · Method: share of items whose id matches /^[0-9a-z]{13}$/i; frame: 500 unique items from 5 page(s), deduplicated by id

The posts those 500 comments sat under were a different story: 100% of them still had a 7-character post ID.

Our data · Dataset: newest-comment-ids-five-subreddits · Source: public Reddit posts, pulled through our API · Query: reddit_subreddit_comments {"limit": 100, "name": ["AskReddit", "worldnews", "gaming", "programming", "nba"]} · Pulled: 2026-10-24 · n = 500 · Method: share of items whose post_id matches /^[0-9a-z]{7}$/i; frame: 500 unique items from 5 page(s), deduplicated by id

The replies are where the two formats meet. 292 of the 500 comments answered another comment rather than the post:

Of the 292 comments that replied to another comment, 97% pointed at a parent whose fullname was the full 16 characters, t1_ plus a 13-character ID.

Our data · Dataset: newest-comment-ids-five-subreddits · Source: public Reddit posts, pulled through our API · Query: reddit_subreddit_comments {"limit": 100, "name": ["AskReddit", "worldnews", "gaming", "programming", "nba"]} · Pulled: 2026-10-24 · n = 292 · Method: share of items whose parent_id matches /^t1_[0-9a-z]{13}$/i; filtered to parent_id matching /^t1_/i; frame: 500 unique items from 5 page(s), deduplicated by id

The other 3% of those 292 replies were new 13-character comments answering an older comment with a 7-character ID, so both formats arrive in the same response.

Our data · Dataset: newest-comment-ids-five-subreddits · Source: public Reddit posts, pulled through our API · Query: reddit_subreddit_comments {"limit": 100, "name": ["AskReddit", "worldnews", "gaming", "programming", "nba"]} · Pulled: 2026-10-24 · n = 292 · Method: share of items whose parent_id matches /^t1_[0-9a-z]{7}$/i; filtered to parent_id matching /^t1_/i; frame: 500 unique items from 5 page(s), deduplicated by id

One of those nine, from r/AskReddit, as our API returned it:

The per-subreddit breakdown, including how long each subreddit took to produce 100 comments:

That spread matters for the fixes below. r/AskReddit produced 100 comments in under a minute, so a poller that falls behind there by one cycle needs a correct watermark, not a lucky one.

Why are new Reddit comment IDs not in order?

Because Reddit wants to create comment IDs in more than one place at once. An admin, quoting Reddit's engineers, said the goal was multi-region and scale-out databases, with several fields inside each ID to rule out collisions. IDs minted by different machines can come out in a different order from the comments' creation times.

The full answer, posted under the September reminder after a developer asked how Reddit avoids collisions without a counter:

The same reply said Reddit "also considered GUIDs but we discard them to avoid the greater impact it would have in other systems as well as the community". What Reddit has and has not said about the design:

• Said: 64-bit integers, base 36, up to 13 characters, several fields inside each ID, no collisions.
• Said: GUIDs were considered and rejected.
• Not said: the bit layout, whether a timestamp sits in the high bits, or how far out of order two IDs can be.

Commenters in both threads compared the design to Snowflake IDs, the 64-bit scheme that puts a timestamp in the high bits and a machine and sequence number below it. Reddit has not published the layout, and an admin said a longer write-up may come on r/RedditEng.

This video walks through how a Snowflake-style generator is built, which is the closest public model of why such IDs are roughly but not strictly time-ordered:

Design a Unique Id Generator in a Distributed System - System Design Interview - Snowflake Algorithm

LeetJourney

And the caution that applies to any time-prefixed ID, from a post this week on UUIDv7:

Arpit Bhayani

@arpit_bhayani

Databases and systems love it when your IDs are sorted. It makes deep pagination so much more efficient. But if you are relying on UUIDv7 for monotonicity and its timestamp, here is something for you... First, why do sorted IDs matter? Most databases keep the primary key in a ht… Show more

Are they in order today?

In our sample, yes, at the resolution we can test. For every pair of comments with different created times, we checked whether the later comment had the larger ID value. Across all 500 comments, comparing every pair regardless of subreddit, that was 124,520 pairs, and none disagreed; within each subreddit alone it was 24,624 pairs, also with none out of order. The 230 pairs created in the same second could not be tested, and created_utc gives nothing finer.

That is a finding about one evening's data, not a promise. Reddit stated the opposite in writing, and a multi-region system can mint a lower ID for a later comment the moment a second region takes writes. Build for Reddit's statement, not for our sample.

What breaks when code sorts Reddit comment IDs as strings?

Every new comment sorts before every old one. A text comparison reads characters left to right, new IDs start with the digit 1, and most old IDs start with a letter, so ORDER BY id, sorted() or max() on the strings puts a reply written this week ahead of a parent written last week.

A real pair from our sample, the reply 19rlvtujyja1t and its parent phxrigp:

ids = ["phxrigp", "19rlvtujyja1t"]

max(ids)                              # 'phxrigp', the older comment
max(ids, key=lambda s: int(s, 36))    # '19rlvtujyja1t', the newer one

Base-36 strings only sort correctly as text when they have the same length, which is why the old habit worked: for years almost every comment ID was 7 characters. Mixed lengths end that. The same applies to a database primary key on a text column, which is why the order of a query result can flip silently even though nothing in your code changed.

The fix depends on what you meant by the sort:

• Newest first: order by created_utc, then by the ID as an integer to break ties, so a replay of the same data gives the same order.
• Exact order of creation: you cannot get it from the ID any more. created_utc is to the second; within a second, accept that the order is arbitrary.
• A stable key for a set: sort by the ID as an integer, which is consistent even if it is not chronological.

What breaks when you use the max comment ID as a watermark?

A poller that remembers the highest ID it processed and then keeps only comments with a higher ID now has two problems. As a string, every new ID is lower than an old one, so it stops seeing new comments. As an integer, Reddit no longer guarantees that a later comment gets a higher ID, so it can skip some.

This was the most common pattern Reddit's announcement threatened. The developer of RemindMeBot replied to the May post within hours:

A watermark that survives the change uses time plus a set, not a single ID:

OVERLAP = 120  # seconds of look-back on every poll

def new_comments(page, state):
    """page: newest-first comments; state: {'since': int, 'seen': set}"""
    cutoff = state["since"] - OVERLAP
    fresh = [c for c in page
             if c["created_utc"] >= cutoff and c["name"] not in state["seen"]]
    for c in fresh:
        state["seen"].add(c["name"])          # t1_ fullname, all 16 characters
    if page:
        state["since"] = max(state["since"], max(c["created_utc"] for c in page))
    # in production, expire fullnames older than the overlap window
    return fresh

The overlap window is the part people leave out. Two comments created in the same second, or a comment that reaches the listing a little late, would be lost by a strict created_utc > since test; re-reading a short window and dropping what is already in the set costs a few duplicates and loses nothing. Our pagination guide covers why the after cursor is not a watermark either: it is opaque, carries paging depth, and is not a comment ID you should store.

For a stream you do not want to poll yourself, our monitoring explainer describes how keyword monitors deliver new comments to a webhook.

Why does JavaScript get new Reddit comment IDs wrong?

Because a new ID is too large for a JavaScript number. A 13-character base-36 ID is around 6.0 x 10^18, and a JavaScript number only holds whole numbers exactly up to 9,007,199,254,740,991. parseInt and JSON.parse round anything larger without an error, so the number you get back is a different ID.

The arithmetic, from MDN on Number.MAX_SAFE_INTEGER:

const id = "19rlvucowhq8z";

Number.parseInt(id, 36);
// 6023915542832964000, stored as 6023915542832963584: 221 off the real value

const toBigInt = (s) =>
  [...s].reduce((n, ch) => n * 36n + BigInt(parseInt(ch, 36)), 0n);

toBigInt(id);                                     // 6023915542832963363n
toBigInt("19rlvtujyja1t") > toBigInt("phxrigp");  // true

The old IDs never came close. phxrigp is 55,504,194,361, so for years parseInt(id, 36) was safe and plenty of code used it to compare comments. It is not safe now. Keep the ID a string everywhere it travels, as our TypeScript guide types it, and convert to BigInt only where you need arithmetic or an integer comparison.

X went through the same thing when its IDs outgrew JavaScript, which is why its API returns id_str beside id, as X's own ID documentation explains. A developer described hitting it this week with tweet IDs:

Sujal

@hecodesforme

my script saved tweet IDs to a JSON file and every lookup after that came back 404 the IDs looked fine. 19 digits, same length as on the site they weren't. 2113619830578241578 went in and 2113619830578241500 came out JSON.parse turns every number into a JS double, and a double

Python is unaffected: int("19rlvucowhq8z", 36) returns the exact value, because Python integers have no fixed size. The risk in a Python stack is the hop into something else, such as a JSON consumer written in JavaScript or a column typed as a 53-bit float.

Which Reddit comment ID columns and regexes need changing?

Any column sized for 7 or 8 characters, any regex that pins the length, and any integer column narrower than 64 bits. New IDs need 13 characters, fullnames need 16, and as integers they need a signed 64-bit type. Reddit's TL;DR singles out exactly this: code that expects fewer than 8 characters.

Storage, for the common databases:

• Text: varchar(16) holds a fullname and varchar(13) a bare ID. A char(7) or varchar(8) either truncates or rejects, depending on the database's strict mode.
• Integer: a signed bigint. Per the PostgreSQL numeric types page, it holds up to 9,223,372,036,854,775,807, and the largest ID in our sample was 6,023,915,575,584,162,885, about 65 percent of that.
• Both: many pipelines keep the text ID as the key and add an integer column only for ordering experiments.

-- PostgreSQL: widen the text key, keep an integer copy, order by time
ALTER TABLE reddit_comments ALTER COLUMN id TYPE varchar(16);
ALTER TABLE reddit_comments ADD COLUMN id_num bigint;
CREATE INDEX reddit_comments_time_idx ON reddit_comments (created_utc, id_num);

Validation is the second place. Patterns like ^[a-z0-9]{6,8}$ or ^[a-z0-9]{7}$ reject every new comment, and a URL parser that slices a fixed number of characters after /comments/ cuts the ID in half. A commenter in the May thread put the right rule simply: allow increased lengths "as long as they're still valid base 36, matching up until the next slash or end of string".

import re

COMMENT_ID = re.compile(r"^[0-9a-z]{1,13}$")
COMMENT_FULLNAME = re.compile(r"^t1_[0-9a-z]{1,13}$")
PERMALINK_COMMENT = re.compile(r"/comments/([0-9a-z]+)/[^/]*/([0-9a-z]+)/?$")

How should you dedupe Reddit comments after the ID change?

On the full fullname, t1_ plus the whole ID, stored as text. A new ID is unique on its own, but a key that trims the ID, drops the type prefix or casts it to a narrow number will collide or corrupt. The fullname is also what Reddit's own parent_id and link_id fields carry.

Three dedupe keys that used to look harmless:

• A prefix of the ID. Shortening IDs for display or a cache key used to be safe because a 7-character ID has little to cut. Every new ID in our sample shared its first three characters, 19r, so a short prefix now collides constantly.
• The bare ID across types. A post ID and a comment ID can be the same string; only the t1_ or t3_ prefix tells them apart. Our bulk fetch by ID guide shows why fullnames are the safe key across endpoints.
• The ID as a float. Any store that silently converts numbers to doubles, a common JSON default, turns two different new IDs into the same number.

What else broke when the new Reddit comment IDs went live?

The first visible breakage was Reddit's own. On 23 October 2026, moderators reported on r/ModSupport that the "load more comments" link on old.reddit had returned a 403 for about a day, and suspected the new IDs. A Reddit community admin replied that the report had been shared with the team. Reddit has not confirmed a cause.

The reporter noted that the same function worked on the new site, which uses a different, private API, and that the error was "extremely unlikely to actually be an auth issue". A commenter offered a workaround, opening the last visible comment's permalink in a new tab so its children load. The bump on Reddit's own announcement thread that linked the report was itself written as a 13-character comment, 19rkfdzdgx7qb.

For tools that read Reddit through the old JSON endpoints, the lesson is the same as for your own code: the paths that page through comment trees with comment IDs, such as "more" children, are where length assumptions hide. Our limitations guide lists the comment-tree limits that already applied before this change.

How does redditapis.com handle the new comment IDs?

Our subreddit comment stream returned comment IDs, parent IDs and post IDs as JSON strings, unchanged, in the 24 October pull above. Separately, on 30 September 2026 we changed how our comment monitors decide whether they missed anything, because that check had compared comment IDs as numbers and the new IDs are too large for it.

What that change does, stated narrowly:

• The old check confirmed a poll had walked past its last-seen comment by comparing IDs. It was built for IDs of up to 10 base-36 digits, so the numbers stay inside JavaScript's exact range, and new 13-character IDs fall outside it.
• The new path applies only to comment streams, and only when the ID comparison cannot decide. The monitor looks the last-seen comment up by its t1_ fullname.
• It treats that comment as passed only on positive evidence: Reddit marks it removed or deleted, and its creation time falls inside the stretch of time the poll actually covered.
• Every other outcome (a failed lookup, a live comment, an unreadable time) leaves the warning in place, so the change can quiet a proven gap and never hide an unknown one.

That is the extent of it. We are not claiming anything about code we did not change. If you build on our monitoring API or the comment stream endpoint, treat the IDs you receive exactly as this post recommends for your own code.

A first call to see the new IDs in your own terminal:

curl -sS "https://api.redditapis.com/api/reddit/sub/programming/comments?limit=25" \
  -H "Authorization: Bearer $REDDITAPIS_KEY"

Reddit comment ID handling by language and database

The language decides whether a new ID survives parsing; the column type decides whether it survives storage. Python, Go's int64 and uint64, Java's long and a signed BIGINT all hold the value exactly. JavaScript numbers, JSON parsed by default, and 32-bit integers do not. Text works everywhere.

• Python: int(id, 36) is exact; PRAW exposes comment.id and comment.fullname as strings, which is the right default. Our REST vs PRAW comparison maps the fields.
• JavaScript and TypeScript: strings by default; BigInt for arithmetic; never Number or parseInt. The Node.js guide shows request code that keeps IDs as strings.
• Go, Java, C#: a signed 64-bit integer is enough, as is a string.
• PostgreSQL, MySQL: varchar(16) or bigint. SQLite stores integers up to 8 bytes, per its datatype documentation.
• Spreadsheets and BI tools: import IDs as text. Most of them store numbers as doubles and will round a new ID the same way JavaScript does.

How to test your code against the new Reddit comment IDs

Add fixtures that mix both formats and run every code path that sorts, stores, parses or validates comment IDs. A useful minimum set is one old ID, one new ID, a reply whose parent is old, and two comments created in the same second, because those four cases exercise every bug in this post.

The fixture set, built from real IDs in our sample and Reddit's own example:

• Old ID: phxrigp, 7 characters, 55,504,194,361 as an integer.
• New ID: 19rlvtujyja1t, 13 characters, 6,023,915,503,351,981,985 as an integer.
• Mixed reply: id 19rlvtujyja1t with parent_id t1_phxrigp.
• Reddit's example: 19gsnavtu46ip, the ID in both admin posts.
• Same-second pair: two new comments with equal created_utc, to prove your ordering has a tiebreak.

The assertions that matter: the newest-first query returns the new comment first, a round trip through your API and database returns the identical string, the validator accepts all of them, and the dedupe step keeps both comments in the same-second pair.

If you keep a Reddit archive, also re-check any job that reads it with a fixed-width parser. Our comparison of live datasets and static dumps covers why a stored corpus needs re-reads, and the Pushshift alternative page covers live reads for teams that relied on an archive.

What to do about the Reddit comment ID change in 2026

Search your code for every place a comment ID is sorted, compared, parsed, sliced, validated or stored, and fix each one the way this post describes. The change is already live on every subreddit, so a pipeline that has not failed loudly may be failing quietly by dropping or misordering comments.

The checklist:

• Grep for ID comparisons: max(, sorted(, ORDER BY id, > between IDs, and parseInt( with radix 36.
• Replace ID watermarks with created_utc plus a short overlap window and a set of seen fullnames.
• Widen storage: text columns to 13 or 16 characters, integer columns to signed 64-bit.
• Loosen validators to 1 to 13 base-36 characters, and stop slicing fixed widths out of URLs.
• Dedupe on the full t1_ fullname, never a prefix or a number.
• Re-run last week's data through the fixed path and compare counts, which is the fastest way to find comments the old code dropped since 21 October.

Reddit's wider API timeline is unchanged by any of this: new Data API requests still close on October 31, as covered in our Reddit Data API access hub, and the RSS end date post covers November 13. When you want a live page of new-format IDs to test against, the quickstart gets a first call running and signup issues a key.