Why Your Link Looks Broken on LinkedIn (and How to Fix It)

Why it matters: you get one attempt

A link preview is a piece of advertising you did not write and cannot revise. It occupies more space in a feed than your post text, it is the first thing anyone's eye lands on, and it is assembled automatically from tags most people never look at.

When it works, a link becomes a card: image, headline, description, domain. When it does not, the same link becomes a bare blue URL that says nothing and looks like spam. Same post, same audience, dramatically different performance — and no error message anywhere to tell you what happened.

The part that turns a small problem into a real one is caching. Platforms scrape a URL once and keep the result. Fix your tags an hour after posting and the broken card stays broken for everybody who sees that post, sometimes for weeks.

The preview is not generated when someone looks at your post. It was generated the first time anyone anywhere pasted that URL — and that is the version everyone gets.

The six reasons previews fail

1. The image URL is relative

<meta property="og:image" content="/images/card.jpg"> looks correct and is the single most common cause of a missing image. A crawler resolving that path does it against its own domain, not yours, so it fetches a URL that does not exist and shows nothing. Always absolute: https://yourdomain.com/images/card.jpg.

2. The image is the wrong shape

Platforms crop to roughly 1.91:1. Feed a square logo into that and the top and bottom disappear, which is why so many shared links show a headless brand mark or half a word of text. 1200 × 630 pixels satisfies Facebook, LinkedIn and X at once, and anything under 600 × 315 drops you to a small thumbnail layout.

3. There are no Open Graph tags at all

Without them the platform guesses: it takes the <title>, scrapes some body text, and hunts for a large-enough image on the page. Sometimes that works. Frequently it produces your navigation menu as a description and a stock photo from three sections down as the image.

4. The image is behind something

A login wall, a hotlink-protection rule, a CDN that blocks unfamiliar user agents, or an og:image hosted on a service that requires a referrer. The crawler is not a browser and does not carry your session. If it cannot fetch the image anonymously, there is no image.

5. The text is cut in the wrong place

Facebook and LinkedIn show roughly two lines of title; X shows one on a narrow screen. A title that reads well in full can read absurdly when the platform stops halfway. This is not a failure exactly — it is just a version of your headline that you never approved.

6. The page is JavaScript-rendered

If your Open Graph tags are injected client-side by a framework, the crawler that reads the raw HTML response never sees them. Social crawlers generally do not execute JavaScript. The tags must be in the served HTML, which is worth verifying rather than assuming — the SEO page checker reads the raw response and reports what is actually there.

The caching problem nobody warns you about

Each platform keeps its own copy of what it scraped, and each expires on its own schedule. Practical implications:

• Facebook caches aggressively. The Sharing Debugger has a “Scrape Again” button that forces a refresh, and it is the only reliable fix.
• LinkedIn caches for a long time. Its Post Inspector will re-scrape a URL on demand. Without that, a bad card can persist for weeks.
• X clears on its own, but it can take a day — long enough for a launch post to underperform completely.
• WhatsApp and Slack cache per-conversation in ways you cannot flush. Adding a harmless query parameter creates a “new” URL and forces a fresh scrape.

All of which means the useful moment to check is before the first share, not after the post underperforms. Once a bad card is cached, you are doing damage control across four platforms with three different tools.

Where this costs real money

A launch announcement

The post you have been building towards for a month, going out to your largest audience at once. Every share and re-share carries whatever card was cached in the first minutes. There is no version of this where checking first is not worth five minutes.

Paid social pointing at a landing page

Meta and LinkedIn both pull page metadata into certain ad formats, and the organic shares your ad generates carry the same card. A broken preview here is not just embarrassing, it is a cost-per-click increase on money you are actively spending.

Client and partner links

Somebody in a Slack channel pastes your proposal page or case study. Whatever renders is what a room full of people who have never heard of you sees first. The card is doing introductions on your behalf, competently or otherwise.

Anything sent over WhatsApp

For a great deal of Indian business traffic, WhatsApp is the sharing layer. It reads Open Graph, it renders a compact card, and it caches per conversation — so a broken preview forwarded through five groups is broken five times.

Why preview rather than post and hope

The official debuggers — Facebook's Sharing Debugger, LinkedIn's Post Inspector — are excellent and you should use them. They have one limitation: the page must already be live. They tell you what went wrong after publishing, which is the wrong side of the deadline.

The previewer here works the other way round. You type the title, description, site name and image URL, and the Facebook, LinkedIn and X cards render as you type — before the page exists, before anything is deployed, while the copy is still editable. You can see the truncation point, notice the image is a square, and fix both while it costs nothing.

Because the image is loaded directly by your own browser, you also find out immediately whether it is reachable and what shape it is. A relative URL, a broken path or a hotlink-protected host fails visibly here rather than silently in production.

It is honest about the trade-off: this renders what you type, not what is on your live page. That is deliberate — it is a design tool, not a diagnostic one. To read the tags off a page that is already published, use the SEO page checker, which fetches the page and reports the Open Graph tags it actually finds. The two answer different questions and neither pretends to answer the other.

A five-minute pre-flight check

1. Design the card before the page ships. Title, description, image — previewed, adjusted, agreed.
2. Export the image at 1200 × 630, under about 1 MB, with any text kept well away from the edges where cropping happens.
3. Generate the tags with the meta tag generator and paste them into the head with an absolute image URL.
4. Publish, then verify the raw HTML contains the tags — not just the rendered page.
5. Run it through Facebook's Sharing Debugger and LinkedIn's Post Inspector once, which both verifies the result and warms their caches with the correct version before your audience arrives.

Then share it. And when the click lands, make sure the page it lands on actually asks for something — a perfect card in front of a page with no next step is a very well-designed dead end.

FAQ