> Content index: https://reachmore.co/blogs/llms.txt
> Canonical page: https://reachmore.co/blogs/tweet-preview

---
title: Tweet Preview: What X Actually Renders in 2026
description: A tweet preview is a prediction, not a render. See where mockup tools and X disagree — t.co counting, link cards, thread splits — and how to check each one.
keywords: tweet preview, x post preview, twitter post preview, tweet mockup, x character counter
published: 2026-09-09
updated: 2026-09-09
url: https://reachmore.co/blogs/tweet-preview
word_count: 2753
---

# Tweet Preview: What X Actually Renders in 2026

> A tweet preview is a prediction, not a render. See where mockup tools and X disagree — t.co counting, link cards, thread splits — and how to check each one.

Canonical: https://reachmore.co/blogs/tweet-preview
Published: 2026-09-09

## Related Pages

- [How to Post Links on X in 2026 Without Killing Reach](https://reachmore.co/blogs/how-to-post-links-on-x-2026)
- [Twitter Thread Maker: How Thread Splitting Really Works](https://reachmore.co/blogs/twitter-thread-maker)
- [How to Pin a Tweet on X — and Why No Tool Can](https://reachmore.co/blogs/how-to-pin-a-tweet)
- [Schedule Tweets: What Happens Between Queue and Post](https://reachmore.co/blogs/schedule-tweets)
- [Best Time to Post on Twitter: 9 Windows That Work](https://reachmore.co/blogs/best-time-to-post-on-twitter)

![black iphone 4 on brown wooden table](https://images.unsplash.com/photo-1579869847557-1f67382cc158?crop=entropy&cs=tinysrgb&fit=max&fm=jpg&ixid=M3w4OTM1MDJ8MHwxfHNlYXJjaHwxfHxzbWFydHBob25lJTIwc2NyZWVuJTIwc29jaWFsJTIwbWVkaWElMjBhcHAlMjBkYXJrJTIwbW9kZXxlbnwwfDB8fHwxNzg4OTI0OTkwfDA&ixlib=rb-4.1.0&q=80&w=1080)

*Photo by [dole777](https://unsplash.com/@dole777?utm_source=quillly&utm_medium=referral) on [Unsplash](https://unsplash.com?utm_source=quillly&utm_medium=referral)*

You hit post. The link you agonized over renders as a bare blue string with no card. The emoji you counted as one character quietly cost two. The thread you split by hand breaks mid-sentence. Your preview showed none of it.

**A tweet preview is a prediction, not a render.** Preview tools draw a mockup in your browser from the text you typed. X builds the real post server-side at publish time — counting characters by weight, fetching your link with its own crawler, and cropping media to the timeline. Where those two disagree is where posts break.

That gap is small but predictable. Once you know the six places a preview guesses, you can check each one in about thirty seconds — and stop shipping posts that looked fine in a tweet mockup and landed badly in the feed.

We build an X composer and a free preview tool, so these six gaps are ones we have had to engineer around directly. Everything below reflects how X's documented counting rules and card pipeline behave as of September 2026.

## What a tweet preview can actually know

**A tweet preview knows your text, name, handle, and attached image, so it can verify character weighting, line breaks, hook width, and both colour modes exactly. It cannot know your link card or the timeline's final image crop, because X decides both server-side after you publish.**

A browser-side preview has your text, your name, your handle, and any image you attached. That's it. Everything else about the final post is decided by X after you press publish.

| What you're checking | Preview can know it | Why |
| --- | --- | --- |
| Character count | ✅ Yes | Weighted counting is a documented, deterministic rule |
| Line breaks and hook placement | ✅ Yes | Pure text layout |
| Light vs dark appearance | ✅ Yes | Both palettes are fixed and public |
| Mention/hashtag/link colouring | ✅ Yes | Simple pattern match on the text |
| Thread split points | ⚠️ Approximate | Depends on the splitter's algorithm, not X's |
| Link card (title, image, domain) | ❌ No | Built server-side from the destination's metadata |
| Image crop in the timeline | ⚠️ Approximate | Depends on viewport and aspect ratio |
| Whether the post gets reach | ❌ No | Ranking is not a rendering question |

The three ✅ rows are why previews are worth using at all. The ❌ and ⚠️ rows are the entire subject of this article.

![Diagram contrasting client-side preview inputs with server-side render decisions on X](https://quillly.com/serve/v1/019c4288-991a-773f-8671-f957d77800e3/images/5d92afd543052c10735d54fc55b6fd89df543087.webp)

## How X counts characters: 280 is a weight, not a keystroke count

**X counts weighted characters, not keystrokes. Every URL costs a flat 23 because of the `t.co` wrapper, CJK and most emoji cost 2, and ordinary Latin text costs 1. A correct X post preview segments emoji into grapheme clusters, so a family emoji costs 2 rather than 4 or more.**

The single most common preview surprise is the counter. X doesn't count characters — it counts *weight*, and the rules are published in [X's own counting-characters documentation](https://developer.x.com/en/docs/counting-characters) and implemented in the open-source [twitter-text library](https://github.com/twitter/twitter-text).

Three rules do almost all the work:

- **Every URL costs exactly 23.** X wraps all links in its `t.co` shortener, so a 12-character link and a 200-character link cost the same 23 of your 280. Shortening a URL yourself saves you nothing.

- **Most Latin text costs 1.** Letters, digits, standard punctuation, and a handful of general-punctuation and dash ranges weigh one each.

- **CJK, Hangul, and most emoji cost 2.** Chinese, Japanese, Korean, and pictographic characters weigh double.

![Bar chart comparing the weighted character cost of different content types on X](https://quillly.com/serve/v1/019c4288-991a-773f-8671-f957d77800e3/images/7b74a4122bf514b3f7c6d882471ba534097ec382.webp)

The emoji rule has a subtlety that trips up naive counters. A family emoji (👨‍👩‍👧) is three people joined by zero-width joiners — four or more code points. A flag (🇮🇳) is two regional indicators. A keycap (1️⃣) is a digit plus a variation selector plus a combining mark. Count code points and you'll charge yourself 4, 6, or more.

X charges 2, because it counts **grapheme clusters** — what a human perceives as one character, formally specified in [Unicode Annex #29](https://unicode.org/reports/tr29/). A correct counter segments text with something like [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter) before weighing anything. ReachMore's [free X character counter](https://reachmore.co/tools/character-counter) does exactly that, which is why an emoji-heavy draft reads the same there as it does in X's composer.

If your preview tool disagrees with X by more than a character or two, it is almost certainly counting code points instead of graphemes — or charging you the literal length of your URLs.

[Count a draft the way X counts it →](https://reachmore.co/tools/character-counter){cta=tool}

## Why your link card never shows up in a preview

**No twitter post preview can render your link card. X's crawler fetches the destination URL after you publish, reads its `og:title`, `og:description`, and `og:image` tags, and builds the card on its own servers. A browser tool never sees that page, so it correctly shows the link as plain blue text.**

This is the honest limit no client-side tool can engineer around, ours included.

When you publish a post containing a link, X's crawler goes and fetches that URL, reads its `og:title`, `og:description`, and `og:image` metadata, and builds the card. The card is assembled **on X's infrastructure, from the destination page** — not from anything sitting in your browser.

![Flowchart showing how X builds a link card server-side after publish, which a browser preview cannot replicate](https://quillly.com/serve/v1/019c4288-991a-773f-8671-f957d77800e3/images/c48c802655c2f660e7a8000061ff25eee89709d5.webp)

So a preview showing your link as plain blue text isn't broken — it's being accurate about what it can see. To actually verify a card, you have to check the destination page's metadata, because that's the only input the card is built from.

Two practical consequences worth knowing:

- **A card can be cached.** If you fixed your `og:image` after someone already shared the URL, X may serve the stale card for a while. Test with a fresh URL parameter.

- **Links carry a real cost inside tooling.** In ReachMore's credit wallet, publishing a plain post costs 15 credits while publishing a post containing a link costs 200 — links are priced separately because they behave differently. Our guide to [posting links on X without killing reach](https://reachmore.co/blogs/how-to-post-links-on-x-2026) covers the placement side.

[See how your draft looks before you publish →](https://reachmore.co/tools/post-preview){cta=tool}

## Where thread splitting quietly breaks

**Thread splitting is the tool's own algorithm, not X's — there is no official splitting endpoint. A good splitter breaks at sentence boundaries first, falls back to whole words, and hard-splits only a single oversized token. A URL straddling the boundary must move whole into the next part.**

If your draft is over 280 weighted characters, something has to split it — and the splitter's algorithm is not X's. There is no official "split this for me" endpoint, so every tool invents its own boundaries.

A good splitter degrades in three stages:

![Flowchart of a three-stage thread splitting algorithm from sentence boundaries down to hard splits](https://quillly.com/serve/v1/019c4288-991a-773f-8671-f957d77800e3/images/039a8d9a5a5dec23e9f4e464efdf14dbee72e47b.webp)

Sentence-first is what keeps threads readable. A splitter that just slices every 280 characters will cut mid-word and mid-sentence, which is the tell-tale sign of a thread assembled by a naive tool.

One edge case matters more than it sounds: **a URL that straddles the boundary must move wholly into the next part.** Because a link costs a fixed 23 no matter its length, splitting it in half produces two broken strings that are no longer links at all — and the character maths stops working. ReachMore's counter moves a straddling URL entirely into the excess for exactly this reason.

For the mechanics of how threads are assembled and posted in sequence, see our breakdown of [how thread splitting really works](https://reachmore.co/blogs/twitter-thread-maker).

## Light mode and dark mode are two different posts

Roughly half of X is read on a black background. A preview that only shows one mode is hiding half your audience's experience.

The two palettes are fixed, and the difference is not subtle:

![Side-by-side comparison of X light mode and dark mode colour values](https://quillly.com/serve/v1/019c4288-991a-773f-8671-f957d77800e3/images/aa43320fd1677b5224869ed37848d6d7ea575b9e.webp)

The failure mode is almost always an image, not text. Screenshots with white backgrounds, charts exported on transparent canvases, memes with pale borders, and diagrams using light grey lines all look deliberate in one mode and accidental in the other. Transparent PNGs are the worst offender: they inherit whatever is behind them, so the same file reads as clean in light mode and as a floating smear in dark.

Check both. It costs one glance and catches a problem you cannot fix after publishing, because [editing posts is a Premium-only feature](https://reachmore.co/blogs/how-to-pin-a-tweet) and the first minutes decide most of a post's distribution.

## The image crop your preview isn't showing

A preview renders your image at whatever size its layout allows. The timeline crops to its own aspect ratio, and the crop point depends on the viewer's screen width.

The practical rule: **assume the top and bottom of a tall image may be cut in the feed.** Put the essential detail — the headline of a chart, the punchline of a screenshot, the face in a photo — in the horizontal middle band. Anyone who taps through sees the whole thing; everyone scrolling past sees only the middle.

This is also why text baked into an image is risky. It survives the crop only if it's centred, and it's invisible to anyone using a screen reader unless you've written alt text.

## A six-point pre-publish check

Run this on any post that matters. It takes about thirty seconds.

1. **Weighted count, not keystrokes.** Confirm your counter charges 23 per URL and 2 per emoji. If it disagrees with X's composer, trust X.

2. **First line under ~50 characters.** The hook has to survive the narrowest screen without wrapping awkwardly.

3. **Both modes.** Look at the post on white and on black, especially if there's an image.

4. **Image middle-banded.** The key detail sits in the centre, not the top or bottom edge.

5. **Link card verified at the destination.** No preview can render it — check the page's `og:` tags instead.

6. **Thread splits at sentences.** If a part starts mid-clause, re-split it by hand.

![Chart showing which pre-publish problems a browser preview can and cannot catch](https://quillly.com/serve/v1/019c4288-991a-773f-8671-f957d77800e3/images/fa3e5686a6151c226e21ec910d8266c07ca2559d.webp)

The last row is the one to internalise. Five of six checks are solvable in your browser. The link card never is — it always requires looking at the destination page.

## Preview, then schedule — without losing the check

A preview is worth most when it sits inside the workflow you actually publish from. Checking a draft in one tab and retyping it into another reintroduces exactly the typos and broken splits you were checking for.

ReachMore is a web app, not a browser extension: you draft in the composer, see the weighted count as you type, and schedule to your own X account. Scheduling itself is free — credits are only charged when a post actually publishes, and only on success. If a post fails, you aren't billed for it. Our guide to [what happens between queue and post](https://reachmore.co/blogs/schedule-tweets) walks through that pipeline, and [best time to post on Twitter](https://reachmore.co/blogs/best-time-to-post-on-twitter) covers when to aim the queue.

[Draft, preview, and schedule in one place →](https://reachmore.co){cta=signup}

## Frequently Asked Questions

### Is a tweet preview accurate?

For text, yes — layout, line breaks, character weighting, and both colour modes are deterministic and fully checkable in the browser. For link cards it can't be accurate, because the card is built by X's crawler from the destination page after you publish. Treat a preview as accurate on text and silent on cards.

### Why does my link count as 23 characters?

X wraps every URL in its `t.co` shortener, so all links cost a flat 23 weighted characters regardless of actual length. A 15-character link and a 300-character link both cost 23. Shortening a URL before pasting it saves you nothing at all.

### Do preview tools upload my draft?

A well-built one doesn't. ReachMore's post preview runs entirely client-side — the text never leaves the page, and an attached image is displayed through a local object URL that's discarded when you navigate away. If a preview tool requires an account to render a mockup, ask why.

### Can I preview a thread before posting it?

You can preview each part and the split points, but the splitter is the tool's own algorithm, not X's — there's no official splitting endpoint. Check that every part lands under 280 weighted characters and that no part begins mid-sentence or cuts a URL in half.

### Why does my image look different after posting?

Two reasons: the timeline crops to its own aspect ratio depending on screen width, and X re-encodes uploaded media. Keep the essential detail in the horizontal middle band, and avoid relying on fine detail or thin text surviving compression.

### Does X Premium change the 280 limit?

Premium subscribers can publish long-form posts well beyond 280 characters, but anything over the limit is collapsed behind a "Show more" link in the timeline. The first 280 still do the work of earning the click, so the hook budget hasn't really changed.

## Key takeaways

A tweet preview answers one question well: *does this post look the way I think it looks?* It cannot answer *what will X build from this?* — because that render happens somewhere you don't control, from inputs you didn't type.

Three things worth keeping:

1. **A tweet preview is deterministic on text and blind on cards.** Trust it completely for counting, layout, and colour modes — never for the link card.

2. **The counter is the tell.** If a tool charges anything but 23 for a URL or 2 for an emoji, it is counting code points, and it will happily let you ship an over-limit post.

3. **Check both colour modes whenever there is an image.** It is the cheapest check on the list and the one people skip.

Use a preview for the five things it verifies perfectly, check the destination page for the sixth, and stop being surprised by the gap. The posts that break in public are almost always the ones nobody looked at on a black background first.

[Check your next post in both modes — free, no sign-up →](https://reachmore.co/tools/post-preview){cta=tool}