Open test data for anyone building a character counter for X — including the cases that have caught real counters, ours among them. Take them, run them against your own code, and tell us if we are the ones who are wrong.
X does not count characters. It assigns each character a weight and allows 280 weight per post. Latin letters, digits and common punctuation weigh 1, and so do Greek, Cyrillic, Hebrew, Arabic and Thai. Chinese, Japanese and Korean characters weigh 2, and so does an emoji. Every link costs a flat 23 whatever its real length.
That much is widely known and still not enough, in two places.
An emoji is one unit, not a string of code points. A complete emoji costs 2 however many code points it is built from. A four-person family emoji is seven code points joined by zero-width joiners. Counting code points and weighting them gives 11. X charges 2.
A link is not “everything up to the next space”. The full stop that ends a sentence is not part of the link before it, and is charged on its own. A bare example.com is a link, and so is main.rs, because X checks the ending against a list of 1,581 and .rs is on it. README.md is not, though .md is on the list too: x.com never treats a bare domain ending in .md as a link. An email address is not a link at all.
We shipped both bugs. Our counter over-counted joined emoji until 27 August 2026, and the test we had comparing our browser copy against our server copy passed every single run — because both copies were wrong in the same way. Two implementations agreeing with each other is evidence of consistency, not of correctness.
Then the first version of this page made the same mistake one level up. It carried 49 vectors, our counters passed every one, and they were still wrong about links until October 2026: a full stop was taken into the link before it, whitehouse.gov was not a link, and an email address was charged 23 for its domain. The vectors could not say so, because the person who wrote the counter also wrote the vectors. What found it was running twitter-text, the library X publishes, over the same strings. Our counter is now a port of that library’s own patterns, and 22 of the vectors below are the cases we had wrong.
The port was wrong too, and we found it on 9 October 2026 by pasting five strings into x.com’s own composer before announcing it. The site no longer counts quite the way the library X publishes does: it never treats a bare README.md as a link, it knows seven domain endings the library does not, its emoji table is newer, and it lets a link follow the mark U+FEFF. Our counter now counts what x.com counts, and three of the vectors below are those cases.
Which is the reason this page exists. Counter tools all claim accuracy, and the ones we measured publish nothing you can check them with. So here is ours, in a form that can falsify it.
That is a lot to read. Five of them catch the mistakes we have found in real counters, ours included — start there if you just want to know whether the counter you use is sound.
curl -s https://postsiete.com/tools/x-vectors.json | jq '.vectors | length' # 74
Served as JSON with Access-Control-Allow-Origin: *, so a browser-based test suite can fetch it directly. MIT licensed. Each vector carries a why giving the arithmetic, so a disagreement points at a specific claim rather than at a number.
const { vectors } = await (await fetch(
'https://postsiete.com/tools/x-vectors.json'
)).json();
for (const v of vectors) {
const got = yourWeightedLength(v.text);
if (got !== v.expected) {
console.log(v.name, 'expected', v.expected, 'got', got, '—', v.why);
}
}
The expected values are derived from the rules x.com applies and stated as arithmetic — they are not snapshots of any implementation, ours included. That matters: a suite generated from an implementation can only ever prove that the implementation agrees with itself.
Arithmetic that reads well can still describe a rule that does not exist, which is how version 1 went wrong. So every expected value is also checked against X itself: on 9 October 2026 the vectors were run through the counting code of x.com’s own composer, and it agrees with all 74. The library X publishes does not, and that is stated here so nobody has to discover it: twitter-text as npm installs it today fails four, a bare README.md, example.music and two emoji, because x.com has moved on since the library’s last release in 2020.
If you believe a vector is wrong, the fastest disproof is to paste the string into X’s composer, without sending it, and read the counter, or to post it and see whether it is accepted at the length claimed. We would rather hear it than be wrong — tell us.
The tables are for reading: a space is drawn as ·, a line break as \n and a joiner as ZWJ. Copy strings from the JSON, not from here.
Plain text in the light ranges. If these fail, nothing else matters.
| Name | Input | Weight | Why |
|---|---|---|---|
| ascii-hello | hello | 5 | Five Latin letters, all weight 1. |
| ascii-sentence | The·quick·brown·fox·jumps·over·the·lazy·dog. | 44 | 44 characters, every one inside the first light range. |
| newlines-count | one\ntwo\nthree | 13 | Line feeds are U+000A — inside the light range, and they are charged, not ignored. |
| latin-accents-precomposed | café | 4 | U+00E9 is a single code point below 0x1100, so 1 like the rest. |
| cyrillic | привет | 6 | Cyrillic sits at U+0400–U+04FF, inside the first light range. Weight 1, which surprises people who assume "non-Latin means 2". |
| hebrew | שלום | 4 | U+05D0–U+05EA, inside the first light range. |
| thai | สวัสดี | 6 | Thai is U+0E00–U+0E7F, inside the light range. Six code points, six units — note this is more than the four grapheme clusters a reader sees. |
Characters outside the light ranges, which cost 2. CJK is the common case and the reason a 200-character Japanese post does not fit.
| Name | Input | Weight | Why |
|---|---|---|---|
| japanese | こんにちは | 10 | Five kana at U+3053 upward, all above 0x10FF, so 2 each. |
| chinese | 你好世界 | 8 | Four CJK ideographs, 2 each. |
| korean | 안녕하세요 | 10 | Five precomposed Hangul syllables at U+AC00 upward, 2 each. |
| mixed-latin-cjk | hello·こんにちは | 16 | 5 Latin (5) + 1 space (1) + 5 kana at 2 (10) = 16. |
The one-emoji-one-unit rule: an emoji in X's table costs 2 however many code points build it. Weighting the code points one at a time is too high on every emoji built from more than one.
| Name | Input | Weight | Why |
|---|---|---|---|
| emoji-simple | 😀 | 2 | One emoji, weight 2. Also the case everyone already passes. |
| emoji-with-variation-selector | ❤️ | 2 | U+2764 plus U+FE0F. Two code points, ONE emoji, so 2. Weighted one code point at a time it is 2 + 2 = 4. |
| emoji-skin-tone | 👍🏽 | 2 | Thumbs up plus a skin-tone modifier is one emoji at 2, not two emoji at 4. |
| emoji-flag | 🇨🇴 | 2 | Two regional indicators forming one flag: 2, not 4. A per-code-point counter reports 4. |
| emoji-zwj-mechanic | 🧑ZWJ🔧 | 2 | Person + ZWJ + wrench = one emoji at 2. Per code point it is 200+100+200 = 5 after dividing by scale, and 5 is the number reported in twitter-text#369. |
| emoji-newer-than-the-published-table | 🐦ZWJ⬛ | 2 | Bird + ZWJ + black large square is the black bird, from Emoji 15.0, and x.com charges it as one emoji: 2. The last emoji table X published, twemoji-parser 14.0.0 from 2022, does not know it, so a counter built on that table charges the pieces: 2 + 1 + 2 = 5. |
| emoji-zwj-family | 👨ZWJ👩ZWJ👧ZWJ👦 | 2 | Four people joined by three ZWJs — seven code points, one emoji, 2. Per code point it is (200*4 + 100*3)/100 = 11. If you get 11, you fell through to the per-code-point path. If you get 7, you counted code points and forgot the weights. If you get 11 in Python, `len()` gave you 7 and something else went wrong too. |
| emoji-two-adjacent | 😀😀 | 4 | Two separate emoji, 2 each. Guards against a cluster walker that swallows neighbours. |
| emoji-in-prose | ship·it·🚀 | 10 | "ship it " is 8 at weight 1, plus one emoji at 2. |
| emoji-keycap | 1️⃣ | 2 | Digit + U+FE0F + U+20E3 is one keycap emoji at 2, not three units. |
| emoji-keycap-without-selector | 1⃣ | 2 | Digit + U+20E3 with no U+FE0F between them is still the keycap emoji at 2. Counted apart they are 1 + 2 = 3. |
| emoji-joined-but-not-a-sequence | 😀ZWJ😀 | 5 | A joiner between two emoji that do not form a known sequence joins nothing: 2 + 1 + 2 = 5. One unit at 2 is only for sequences in the emoji table. |
The flat 23, and where X finds a link: with or without a protocol, on any of the 1,581 endings x.com recognises, stopping before the punctuation that ends a sentence.
| Name | Input | Weight | Why |
|---|---|---|---|
| url-https-short | https://x.com | 23 | Flat 23 regardless of length — 13 characters charged as 23. Links can cost MORE than they are long. |
| url-https-long | https://example.com/a/very/long/path?with=query&and=more#fragment | 23 | Same flat 23. 65 characters charged as 23. |
| url-www-no-scheme | www.example.com | 23 | A www. host with no scheme is still linkified. |
| url-bare-domain | example.com | 23 | THE ONE THAT UNDERCOUNTS. No scheme, no www., still a link, still 23. A matcher requiring http(s):// or www. reports 11 and tells the author a post fits that the API will reject. |
| url-bare-domain-with-path | example.com/pricing | 23 | The path is part of the link, so still one 23 rather than 23 plus the path. |
| url-in-prose | read·this:·https://example.com·now | 38 | "read this: " is 11 characters at weight 1, the link is a flat 23, and " now" is 4. 11 + 23 + 4 = 38. The text either side of a link must keep its own weighting. |
| url-two-links | https://a.com·https://b.com | 47 | 23 + 1 space + 23 = 47. |
| url-adjacent-to-cjk | こんにちは·https://example.com | 34 | 5 kana at 2 (10) + 1 space + 23 = 34. Checks that the link split does not lose the weighting of the text around it. |
| url-then-full-stop | Read·more:·https://example.com/post. | 35 | "Read more: " is 11, the link is a flat 23, and the full stop is 1: 35. A path may not END on a full stop, so the stop belongs to the sentence. A matcher that runs to the next space takes it into the link and reports 34: one short, whenever a sentence ends with a link. |
| url-then-comma | See·https://example.com,·then·reply | 39 | "See " is 4, the link is 23, and ", then reply" is 12: 39. The comma is not part of the link. |
| url-in-brackets | (https://example.com) | 25 | 1 + 23 + 1 = 25. The closing bracket has no opening one inside the link, so it stays outside. |
| url-then-question-mark | Is·it·https://example.com/pricing? | 30 | "Is it " is 6, the link is 23, the question mark is 1: 30. A query needs something after its "?", so a bare one ends the sentence, not the link. |
| url-brackets-inside-the-path | https://en.wikipedia.org/wiki/Primer_(film) | 23 | Brackets that open and close inside the path are part of it, which is what keeps a Wikipedia link whole. One link, 23. |
| url-full-stop-is-the-281st | aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa·https://example.com. | 281 | 256 + 1 space + 23 + 1 full stop = 281, one over the limit. A counter that takes the stop into the link says 280 and calls this postable. This is the vector that costs somebody a rejected post. |
| url-markdown-ending-with-protocol | https://example.md | 23 | With a protocol, .md is an ending like any other (it is the country ending of Moldova), so this is a link at 23. The exception x.com makes for .md applies to bare domains only. Compare not-a-url-markdown-file. |
| url-ending-newer-than-the-published-list | example.music | 23 | .music is one of seven endings x.com recognises that are missing from the list X published in twitter-text, so this bare domain is a link at 23. A counter that uses the published list sees thirteen ordinary characters and reports 13. |
| url-government-ending | whitehouse.gov | 23 | A bare domain on an ending outside the handful everyone remembers. x.com recognises 1,581 of them; a counter with a short list of its own reports 14. |
| url-missing-space-makes-a-link | the·end.Next·sentence | 36 | "the " is 4, "end.Next" is a link at 23 because .next is a generic ending and case does not matter, and " sentence" is 9: 36. A missing space after a full stop can manufacture a link. |
| url-upper-case | EXAMPLE.COM | 23 | Link matching ignores case, so capitals change nothing: 23. |
| url-non-latin-with-protocol | http://пример.рф | 23 | With a protocol, a domain in any script is a link: .рф is the Cyrillic country ending of Russia. 23. Compare not-a-url-non-latin-bare. |
| url-bare-domain-query-left-out | example.com?q=1 | 27 | Without a protocol a query is only kept when a path comes before it. Here the link is example.com at 23 and "?q=1" is 4 more: 27. With https:// in front the whole string is one link at 23. |
Text that must NOT be charged 23: an email address, an ending that is not one, a domain glued to a "#". A spurious 23 sends an author rewriting copy that already fitted.
| Name | Input | Weight | Why |
|---|---|---|---|
| not-a-url-eg | e.g.·this·is·prose | 18 | "e.g." is not a link. Charging it 23 would report 37 for an 18-unit sentence and send an author rewriting copy that fits. |
| not-a-url-filename | see·index.js·for·details | 24 | .js is not a domain ending, so this is 24 plain characters. A counter matching any dotted token charges 23 for the filename. Compare not-a-url-markdown-file, where .md is an ending and the file name is still not charged as a link. |
| not-a-url-markdown-file | I·updated·README.md | 19 | "I updated " is 10 and README.md is 9 ordinary characters: 19. .md is the country ending of Moldova, and X's published library makes README.md a link at 23, but x.com does not: there a bare domain ending in .md is a file name, not a link. With https:// in front it is a link again; see url-markdown-ending-with-protocol. |
| not-a-url-version | version·2.78.0·shipped | 22 | Neither "78" nor "0" is a domain ending, so a version string is 22 ordinary characters. |
| not-a-url-sentence-end | It·is·done.Then·we·ship. | 24 | "then" is not a domain ending, so the missing space manufactures nothing and this is 24 characters. That is luck rather than a rule: see url-missing-space-makes-a-link. |
| not-a-url-almost-tld | example.coma | 12 | .coma is not a domain ending, so this is twelve ordinary characters — which means "example.com" costs 23 and "example.coma" costs 12, and ADDING a character made the post cheaper. Surprising, correct, and the clearest demonstration that link detection is decided on the whole token rather than incrementally. |
| not-a-url-ellipsis | wait...what | 11 | Consecutive dots are not a hostname. |
| not-a-url-email | mail·jane@example.com·today | 27 | A domain straight after "@" is not a link, so the address is 16 ordinary characters: 5 + 16 + 6 = 27. Charging the domain 23 reports 39 and tells an author a post that fits is too long. |
| not-a-url-after-hash | #example.com | 12 | A domain straight after "#" is not a link. The same goes for "$", "@", a letter or a digit. Twelve characters, 12. |
| not-a-url-no-ending | http://localhost:3000 | 21 | A protocol is not enough: the host must finish with a recognised ending, and localhost has none. 21 characters, 21. |
| not-a-url-other-scheme | ftp://example.com | 17 | Only http and https start a link, and a bare domain may not directly follow a slash, so nothing here is one. 17 characters, 17. |
| not-a-url-www-without-ending | www.example | 11 | "www." does not make a link; a recognised ending does, and "example" is not one. Eleven characters, 11. |
| not-a-url-label-too-long | aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.com | 68 | One part of a domain may be at most 63 characters. This one is 64, so the whole string is 68 ordinary characters. At 63 it would be a link at 23. |
| not-a-url-underscore-in-the-name | my_site.io | 10 | An underscore is allowed in a subdomain but not in the name next to the ending, and a bare domain may not start straight after one, so neither "my_site.io" nor "site.io" is a link. Ten characters, 10. |
| not-a-url-non-latin-bare | пример.рф | 9 | Without a protocol only an ASCII domain is linked. Eight Cyrillic letters and a dot, all at weight 1: 9. Compare url-non-latin-with-protocol. |
The same visible string must cost the same however it was encoded.
| Name | Input | Weight | Why |
|---|---|---|---|
| nfc-decomposed-accent | café | 4 | "cafe" + U+0301 combining acute normalises under NFC to "café", four code points at weight 1. Without normalisation this is 5, so the same visible word costs differently depending on which editor produced it. |
| nfc-korean-decomposed | 가 | 2 | Two conjoining jamo normalise under NFC to the single syllable 가 (U+AC00), which is above 0x10FF and so costs 2. Unnormalised, the jamo are also above 0x10FF and would cost 4. |
The exact edges of the published ranges. Off-by-one lives here.
| Name | Input | Weight | Why |
|---|---|---|---|
| boundary-last-light-char | ჿ | 1 | U+10FF is the last code point of the first light range. Inclusive, so 1. |
| boundary-first-heavy-char | ᄀ | 2 | U+1100 is one past the range. 2. Together with the previous case this pins the edge in both directions. |
| boundary-general-punctuation-start | EN QUAD | 1 | U+2000 opens the second light range. |
| boundary-zwj-alone | ZWJ | 1 | A bare ZWJ is the last code point of the second range, weight 1. This is the value that makes the family emoji 11 rather than 14 when counted wrongly, so it is worth pinning on its own. |
| boundary-just-past-second-range | LRM | 2 | U+200E, the left-to-right mark, is one past the second range and costs 2. Invisible and expensive. |
| boundary-en-dash | – | 1 | U+2013 is inside 0x2010–0x201F. Dashes and smart quotes are cheap; that is the point of the third range. |
| boundary-prime | ′ | 1 | U+2032 opens the fourth range, 0x2032–0x2037. |
| boundary-just-past-fourth-range | ‸ | 2 | One past the last light range. |
Empty strings, whitespace, and the degenerate inputs that produce a crash rather than a wrong number.
| Name | Input | Weight | Why |
|---|---|---|---|
| empty | (empty) | 0 | Nothing costs nothing. |
| single-space | · | 1 | U+0020 is inside 0x0000–0x10FF, so 1. |
| exactly-280-ascii | aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa | 280 | The limit itself. Fits — the comparison is <=, not <. |
| over-by-one | aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa | 281 | One over. The two cases together pin which way the boundary falls. |
| cjk-140-fills-280 | 漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢漢 | 280 | 140 ideographs at 2 each is exactly the limit — the arithmetic behind "a Japanese post gets half as many characters". |
Not official, and not the first. X publishes twitter-text under Apache 2.0 with its own conformance tests, and our counter runs the 1,706 of them that concern weighted length and links. If you want the canonical suite, use theirs. What is here is narrower: JSON a browser can fetch, the arithmetic attached to every expected value, and the cases around what follows a link and what is not one.
Not timeless. The rules are x.com’s as read on 9 October 2026. X has changed its composer since twitter-text’s last release without publishing the changes, and it can do so again. Emoji newer than Emoji 15.0 are charged by the piece because x.com charges them that way today. When X changes the rules, this page is wrong until somebody notices, which is what the section above is for.
emojiParsingEnabled — the weighted length “considers all emoji as a single code point … including longer grapheme clusters combined by zero-width joiners.”