You fixed the Open Graph tags, dropped the link into a WhatsApp chat to check, and the preview is still wrong: the old title, no image, or no card at all beyond the bare URL. It is a familiar way to lose half an hour, because WhatsApp tells you almost nothing about what it saw or why it gave up.
This post covers three things: how WhatsApp actually builds that little preview card, the short list of reasons it comes out wrong, and the one-character trick that makes WhatsApp read your page again instead of showing you a cached, out-of-date version. If you would rather skip straight to a diagnosis, the WhatsApp Link Preview Debugger fetches your page the same way WhatsApp does and tells you what it found.
How WhatsApp builds a link preview
When you paste a URL into a chat, your phone does not read the page. WhatsApp’s own servers fetch it, once, and pull a few tags out of the HTML to assemble the card: a title, a short description, and an image. It looks first for Open Graph tags (the `<meta property="og:...">` lines a page puts in its `<head>`), falls back to Twitter card tags if those are missing, and finally to the plain `<title>` element when there is nothing else.
The three tags that matter most are `og:title`, `og:description` and `og:image`. Get those right and you get the card you expect. Here is what a complete set looks like:
<meta property="og:title" content="Your page title"> <meta property="og:description" content="A one-line summary of the page."> <meta property="og:image" content="https://example.com/preview.jpg">
One detail explains most of the trouble people hit: the fetch is done by a bot, not a browser. WhatsApp sends a crawler user agent, downloads the raw HTML, and stops. It does not run JavaScript, it does not scroll, and it does not wait for anything to load. Whatever sits in the HTML your server returns on the first response is all WhatsApp will ever see.
The usual reasons a preview breaks
Most broken previews come down to one of the causes below. They are roughly in the order worth checking.
The tags aren’t in the HTML
If the page has no `og:title` or `og:image`, WhatsApp has little to work with. It may fall back to the `<title>` and show a plain card with no picture, or show nothing but the link. Open the page, view source, and search for `og:`. If those lines are not there, WhatsApp never saw them either.
The tags are added by JavaScript
This is the one that catches modern sites. If your framework injects the meta tags after the page loads (a single-page app, or client-side rendering), they exist in the browser but not in the raw HTML. WhatsApp does not run that JavaScript, so it reads the empty shell and finds nothing. The tags have to be in the HTML the server sends, before any script runs. Server-side rendering or a prerender step is the fix.
The image is too small, too heavy, or not HTTPS
For the big image card, `og:image` needs to be a real, reachable picture of a reasonable size. Below roughly 300×200 pixels WhatsApp tends to drop to a small thumbnail or skip the image; a very large file (over about 5 MB) can be dropped too. The image URL must be https, and it has to load without a login. A common miss: the image is served from a signed CDN or S3 URL with a token that expires, so the preview works today and 404s next week once the token dies.
The page blocks the crawler
If the page sits behind a login, returns a 401 or 403, or blocks unfamiliar user agents at the CDN, WhatsApp gets a wall instead of your HTML and cannot build a card. Some sites gate Open Graph tags behind a recognized preview bot, which is why the same URL can preview on one platform and not another.
The title or description is too long
This does not stop the preview, it just trims it. WhatsApp cuts a title after about 65 characters and a description after about 160, so a long title gets clipped mid-sentence. Write the important words first and keep `og:title` short.
The page is slow, or redirects too much
The crawler waits only so long. A page that takes several seconds to respond, or one buried under a chain of redirects, can time out before WhatsApp reads the tags. Point the link at the final URL and keep the first response fast.
The trick: make the URL look new
Here is the part that trips up almost everyone, and the reason a preview stays wrong long after you have fixed the page. WhatsApp caches the preview against the exact URL. Once it has fetched your page and built a card, it reuses that card for the same link and does not fetch again for a good while. So you can correct every tag, and the link you already shared keeps showing the old, broken preview, because WhatsApp is not reading your page, it is reading its own cache.
The way around it is to change the URL so WhatsApp treats it as one it has never seen. Add a query parameter your page ignores:
https://example.com/your-page → https://example.com/your-page?v=2
Any parameter works (`?v=2`, `?x=1`, `?refresh=1`), as long as the URL string is different from the one WhatsApp already cached. It sees a new URL, fetches the page fresh, and reads your current tags. If you need to check again after another edit, bump the number: `?v=3`, then `?v=4`. Most pages ignore an unknown query parameter, so this changes nothing about what the visitor sees.
One honest caveat. This gives you a working preview to test and to share from now on, but it does not clear the cache on your original clean URL. That entry ages out on WhatsApp’s own schedule, which Meta does not publish and which can run to weeks. So use the parameter to confirm the fix and to hand out a link that previews correctly today, rather than expecting the bare URL to refresh on its own.
See what WhatsApp sees, without guessing
Pasting a link into a real chat over and over is a slow way to debug, because you only ever see the result, never the reason. The WhatsApp Link Preview Debugger does the fetch for you: it requests your page as WhatsApp’s crawler, shows the exact title, description and image it found, and gives a plain-language read on what is missing or too long. When Open Graph tags are absent it writes the `<meta>` lines for you to copy in, and it has a cache-busting button that applies the query-parameter trick above. Check the page there first, fix what it flags, then share the link for real.
Frequently asked questions
Why does WhatsApp still show the old preview after I fixed the page?
WhatsApp cached the preview against that exact URL and is serving the cached card instead of re-reading your page. Add a query parameter (for example `?v=2`) to make it fetch the page again, or wait for WhatsApp’s cache to expire on its own.
Does WhatsApp run JavaScript when it reads my page?
No. WhatsApp’s crawler downloads the raw HTML and stops. If your Open Graph tags are added by client-side JavaScript, WhatsApp never sees them. The tags must be in the HTML the server returns, which usually means server-side rendering or a prerender step.
Why is there no image on my WhatsApp preview?
The most common causes are a missing `og:image` tag, an image under about 300×200 pixels, an image served over http instead of https, an image behind a login or an expiring signed URL, or an image tag added by JavaScript. Check the winning image with the Link Preview Debugger.
How long does WhatsApp cache a link preview?
Meta does not publish the exact duration, and in practice it can persist for weeks. That is why you cannot rely on the cache clearing on its own during testing, and why the query-parameter trick is the reliable way to see a fresh preview now.