You paste 900 words into a Twitter thread maker, it hands back four neat posts, and X rejects the third one for being too long. The tool counted characters. X doesn't count characters.
A Twitter thread maker splits a long draft into posts that each fit X's limit, then chains them as replies. The good ones split on X's weighted character count — where every URL costs 23 and most emoji cost 2 — and break at sentence boundaries. The bad ones count characters and hand you posts X won't accept.
That difference sounds pedantic until a thread you spent an hour on dies halfway out. Here's the actual math, where splitters break, and what a thread costs to publish once you're doing it through the API.
What a Twitter thread maker actually does#
Three jobs, and most tools only do the first one well.
Measure. Work out how long your text is the way X measures it, which is not the way your text editor measures it.
Split. Cut the draft into parts that each fit, breaking at places a reader won't notice — end of a sentence, not the middle of a word.
Chain. Publish the parts in order, each one as a reply to the last, so they render as a thread instead of five orphan posts.
The measuring step is where nearly all the accuracy lives, and it's the step nobody advertises. So start there.
Why 280 characters isn't 280 characters#
X's 280 limit is measured in weighted characters, not code points. Latin-script letters weigh 1, CJK and emoji weigh 2, and every URL costs a flat 23 no matter its real length. So a post your text editor calls 250 characters can easily be 320 to X.
The rules come from twitter-text, the counting library X publishes, and they're stranger than most people expect:
Any URL counts as exactly 23, no matter its real length. X wraps every link in a t.co shortener before it's posted, so
bit.ly/xand a 400-character tracking URL cost you the same 23.Latin, Cyrillic, Greek, Hebrew, Arabic and Devanagari characters weigh 1. That's the "light" range — roughly the first 4,351 code points, plus smart quotes, dashes and primes.
Everything else weighs 2. CJK, Hangul, and most emoji.
Emoji are counted per grapheme cluster, not per code point. 🇮🇳 is two code points and 👨👩👧 is five, but each weighs 2, not 4 or 10.
The URL bar is the one that wrecks threads. Drop three links into a post and you've spent 69 of your 280 before writing a word — but a naive character counter sees x.com/a as 7 characters and tells you you're fine.
The three things that break a naive splitter#
Every failure mode traces back to counting the wrong thing.
Links. A splitter counting raw characters will happily pack a post with four URLs and 240 characters of prose. Real weight: 240 + 92. X rejects it.
Emoji and non-Latin scripts. A Japanese or Korean draft is roughly twice as expensive as the character count suggests. Split a CJK thread at 280 characters and every single part is about 560 weighted — every one bounces.
Splitting mid-URL. This is the ugly one. A splitter that cuts at a character boundary can slice a long link straight down the middle, leaving half a dead URL at the end of one post and a meaningless fragment at the start of the next. A weight-aware splitter treats a URL as one atom: it either fits whole or moves entirely to the next post.
If you want to see the difference on your own draft, ReachMore's free X character counter does the weighted count live and splits anything over the limit into thread-sized parts. No account needed.
Where a good splitter cuts: sentences, then words#
A good splitter cascades through boundaries: sentence ends first, then word gaps, and only hard-splits mid-word when a single token is longer than the whole limit. That keeps every part readable instead of ending each post mid-clause.
Fitting the limit is necessary but not sufficient. A thread that breaks mid-clause reads like a fax transmission.
The sane approach is a cascade — try the most natural boundary first, fall back only when you have to:
That cascade is how we built the splitter behind ReachMore's own character counter, and in practice the last branch almost never fires — it takes a 280-weight unbroken token to get there. But it's the difference between a splitter that degrades gracefully and one that throws an error at you.
Worth saying: splitting is mechanical, and mechanical splitting is not thread writing. A tool can guarantee each part fits. It can't make part three worth reading. That's still on you — our guides to writing threads on X and thread hooks that stop the scroll cover the half software can't do.
Posting the thread is N API calls, not one#
Here's the part that surprises people who move from copy-paste to automation: X has no "post a thread" endpoint.
A thread is N separate post-creation calls. The first is a normal post. Every one after it passes the previous post's ID as in_reply_to_tweet_id, which is what makes the chain render as a thread rather than five loose posts.
Three consequences fall straight out of that:
Partial failure is real. If call five fails, you have a four-post thread live on your timeline and three posts in limbo. Ask any tool you're evaluating what it does here. Retrying blindly is how accounts end up with a duplicated post four in the middle of a thread.
Every part is billed separately. There's no bulk discount on an endpoint that doesn't exist.
Every part counts against your rate limits. Which is the next problem.
Publish and pace your posts from one place → Open ReachMore — credit wallet, one-time top-ups, credits never expire, charged only when a post actually goes out.
The rate limits a long thread runs into#
X's write limits are enforced per 15-minute window, not per day, and a thread is the easiest way to hit one without meaning to.
ReachMore's own guardrails sit deliberately below X's thresholds: 50 outbound posts per day, 15 per 15-minute window, and a minimum 5 seconds between sends on an account. A 12-part thread is fine. A 20-part thread doesn't fit in one window — it has to be paced across two, or it trips the burst cap.
That pacing isn't a limitation to route around, it's the point. Firing twenty posts in ninety seconds trips X's own limits and pattern-matches to spam even when every post is good, which is exactly the behaviour X's platform manipulation policy exists to catch. Our breakdown of what actually breaks under X's rate limits goes deeper on the platform side.
The practical read: keep threads under about 15 parts. That's also better writing advice than it is API advice.
What a thread costs to publish#
Posting a thread by hand in the X app is free. Through the API every part is billed separately: in ReachMore that's 15 credits per post, or 200 for a post containing a link. A seven-part thread costs 105 credits clean, or 290 with one link in it.
If you're posting by hand in the X app, a thread is free and you can skip this. If you're posting through the API, every part has a price, and one part probably costs more than all the others combined.
ReachMore prices each action to mirror X's own pay-per-use tier: 15 credits to publish a post, and 200 credits to publish a post that contains a link. Charged on success only — a failed call costs nothing.
A single URL nearly triples the cost of the thread. That's X's pricing, not a markup — X charges a punitive tier for any content containing a URL.
The useful part is that the billing incentive and the algorithm point the same direction. Links suppress reach in the feed too, so the move that saves you 185 credits is the same move that protects your distribution: publish the thread clean, then put the link in a follow-up reply once the thread has run.
Check your draft's real weighted length → Open the free X character counter — live weighted count, t.co URL math, and automatic thread splitting.
How to pick a Twitter thread maker#
Test any thread maker in under a minute: paste a long URL and check the count rises by exactly 23, paste CJK or emoji text and check each weighs 2, then split a long draft and confirm the parts end at sentence boundaries with no link cut in half.
Most tools in this category — whether they bill themselves as an X thread generator, a Twitter thread splitter, or a thread maker — are a textarea and a substring call. Four questions separate the real ones:
Does it count URLs as 23? Paste a post with a long link into the tool. If the count matches your text editor's, it's counting characters and you'll get rejections.
Does it handle emoji and non-Latin text? Paste a line of CJK or a few flag emoji. A correct counter weighs those at 2 per grapheme.
Where does it break? Look at whether parts end at sentence boundaries or mid-word.
What does it do about links? Both the counting and the placement — a tool that doesn't warn you about a link in post one is costing you reach.
And the honest alternative worth considering: if your draft is 900 words of continuous argument, a thread may be the wrong container entirely. X long-form posts hold the whole thing in one place, with no splitting and no chain to break. Threads win on skimmability and per-part engagement; long-form wins on coherence.
Frequently Asked Questions#
How many posts should a Twitter thread be?#
Under 15 is the practical ceiling, for two reasons that happen to agree. Reader attention drops sharply after about the eighth post, and 15 outbound posts is where per-15-minute write limits start to bite when you're publishing through the API. If your draft needs 25 parts, it needs editing or it needs long-form.
Does X count a URL as 23 characters even if it's short?#
Yes. X wraps every link in its t.co shortener before posting, so all URLs cost the same fixed 23 weighted characters regardless of real length. A five-character link and a 400-character tracking URL are identical to the counter — which means shortening a link before you post it saves you nothing at all.
Can I schedule a thread?#
You can schedule the posts. Because X has no thread endpoint, a thread is N chained calls, so scheduling one means scheduling a sequence and handling what happens if part five fails. ReachMore's scheduler queues posts and charges only when one actually publishes — reshuffling a queue all week costs nothing.
Why did X reject a post my thread maker said was fine?#
Almost always weighted length. Your tool counted characters; X counted weight. The usual culprits are a URL the tool measured literally instead of as 23, or emoji and non-Latin characters it weighed as 1 instead of 2. Run the same text through a weighted counter and the discrepancy shows up immediately.
Is a thread better than a single long post?#
It depends on the content. Threads earn more per-part engagement and are easier to skim, and each part is its own entry point into the conversation. A single long-form post keeps a continuous argument coherent and can't break mid-chain. Sequential how-tos and lists suit threads; sustained reasoning usually doesn't.
Do emoji really count double?#
Most do. Emoji sit outside X's light-weight ranges, so they weigh 2 — but they're measured per grapheme cluster, not per code point. A family emoji built from five code points still weighs 2, and so does a two-code-point flag. Ten emoji cost you 20 of your 280.
Key takeaways#
A Twitter thread maker is worth using for exactly one reason: it measures your draft the way X measures it, and a text editor doesn't. Every URL is 23. CJK and emoji are 2. Split on those numbers, break at sentences, keep links atomic, and your thread posts on the first try.
Then the mechanical part is done, and the actual work — a hook worth stopping for, parts worth reading to the end — starts. Promoting the thread after it's live and reusing the good ones are where the compounding is.
Sources:
twitter-text — X's own weighted character counting library
X API Documentation — X Developer Platform
X Platform Manipulation and Spam Policy — X Help Center
