Guide

How LinkedIn and X (Twitter) unfurl the same URL

They do not read the same tags, and they do not show the same fields. LinkedIn is Open Graph with a landscape card and a snippet. X decides layout from twitter:card, then fills title and image from Twitter tags with OG as fallback. A generic “social preview” that ignores that split will lie about at least one of them.

This is the difference that matters in practice, the tags each client actually uses, and a small set that works for both. CardScope reconstructs the two shells from those tags — it is not a screenshot of the live page.

Same og:title, og:description, and 1200×630 image, with twitter:card=summary_large_image. LinkedIn keeps the description under the title. X’s large card is image, title, domain — the description usually does not appear on the card.

Why the same URL looks different

Two crawlers, two vocabularies. LinkedIn is Open Graph–only: if you only ship twitter:*, the LinkedIn card is often a bare URL. X reads twitter:* first and falls back to og:*, so a complete OG set can still unfurl on X — but layout is not OG’s job. That switch is twitter:card.

The image file is usually the same 1.91:1 landscape. The crop is similar. What changes is which tags are required, whether a description shows, and whether you get a billboard or a small square thumb.

What LinkedIn typically reads

LinkedIn’s unfurler is Open Graph–first and, in practice, OG-only. Twitter Card tags are ignored. It wants:

• og:title — the headline. Titles commonly clip near 100–110 characters. Put the meaning in the first clause.
• og:description — the snippet under the title. Often around 120 characters before it clips. Front-load the sentence.
• og:image — a landscape file. LinkedIn’s documented target is about 1.91:1 (1200×627 is the figure they have published; 1200×630 is the usual large-card size and is close enough). Images under ~200px on a side are often dropped.
• og:image:width and og:image:height — set them. Clients are happier when they know the size before they commit to a layout.
• og:url — the permalink the card should represent. Query-string variants can cache as separate objects; a stable canonical URL helps.

The domain under the snippet comes from the URL, not from og:site_name. og:site_name is still worth setting for Slack and Discord; LinkedIn will not use it as the card kicker.

LinkedIn caches aggressively. After you fix tags, the old card can stick in a composer or a feed. LinkedIn’s Post Inspector is the usual official way to see what they currently have for a URL and to ask them to look again. A checker that fetches live HTML will show the new tags immediately; LinkedIn itself may not. There is no public, documented cache-bust API beyond that inspector flow — do not expect a query parameter on your permalink to flush their copy.

What X typically reads

X reads Twitter Card tags first, then falls back to Open Graph, then to the document <title> / meta description. The important switch is twitter:card:

• summary_large_image — large landscape photo above the title and domain. This is what most product and blog links want. Description is typically omitted on the card itself.
• summary — small thumbnail beside the title and a short description. Fine for a profile or a square icon; disappointing for a launch post.
• Missing twitter:card — X may not render a card at all, even if OG is complete. Set the tag.

Title prefers twitter:title, then og:title, then <title>. X usually cuts around 70 characters. Description prefers twitter:description, then og:description — it matters for summary, not for the large card. Image prefers twitter:image (or twitter:image:src), then og:image.

A square image on summary_large_image letterboxes. If the file is 1:1, either ship a 1200×630 crop or accept the small summary card. Relative image URLs and HTTP images get dropped.

X also caches. After you change tags, a checker that fetches live HTML will show the new values; a post you already composed on X may still show the old card. Recheck the permalink after a cache-busting share (or a fresh composer) rather than assuming the first unfurl is final.

Tags that matter (and who uses them)

A minimal set that works for both

If you only set eight things, set these:

<meta property="og:title" content="A specific title, not the brand name">
<meta property="og:description" content="One sentence, 70–110 characters.">
<meta property="og:image" content="https://example.com/og.png">
<meta property="og:image:width" content="1200">
<meta property="og:image:height" content="630">
<meta property="og:url" content="https://example.com/permalink">
<meta name="twitter:card" content="summary_large_image">
<meta name="twitter:title" content="A specific title, not the brand name">

That is enough for LinkedIn’s OG landscape card and X’s large photo card. LinkedIn will not read the Twitter tags; X will fall back from twitter:title to og:title if you skip the duplicate. Add twitter:image / twitter:description only if those should ever differ from OG.

Keep important pixels in the center of the image. Do not put the only readable type in a corner LinkedIn or X might crop.

How to verify

View-source or a browser extension shows you the tags your browser got. That is not what LinkedIn or X fetched: different user-agent, no cookies, often a different final URL after redirects, and their own image probe. Both platforms cache. Fresh tags in your HTML do not mean a fresh card in a composer.

1. Paste the permalink into CardScope. It fetches from the edge, reads OG and Twitter tags in memory, and discards the HTML.
2. Compare the LinkedIn and X shells. LinkedIn should have a landscape image, title, and snippet from OG. X should show large vs small based on twitter:card, with Twitter tags first and OG as fallback. These are reconstructed shells, not live screenshots.
3. Fix the tags on the live URL: absolute https:// image, dimensions, og:* for LinkedIn, twitter:card for X.
4. Recheck the same permalink. If CardScope is current but LinkedIn or X is stale, refresh LinkedIn via Post Inspector and share on X from a fresh composer. Platform cache is separate from the checker.