Skip to content

Link previews

What is a link preview, and how do apps build one?

By Hannah Voss, Editor · Reviewed September 2026 · Updated · 8 min read

Quick answer

A link preview is the card a chat app or social network shows under a pasted URL, usually four parts: an image, a title, a short description and the site name. The app fetches your page, reads its Open Graph, Twitter Card or oEmbed data, builds the card, and keeps a copy.

A cut-paper link preview card with a grey landscape panel, two blank text bars and a small embossed seal in one corner

Paste a URL into Slack, WhatsApp, LinkedIn or a Facebook post and, a second later, a small card appears: a picture, a bold title, a line or two of text and the name of the site. That card is the link preview. Slack calls the process unfurling. Readers decide from it whether to click, so the card is often the first thing anyone sees of your page.

The card is not a screenshot. The app reads a handful of tags in your page head and lays them out in its own design. Change the tags and you change the card. This page explains where those values come from; the rest of our Open Graph and link previews section covers each network's quirks and tools.

Every platform works a little differently, but the documented pieces line up into four stages.

How an app builds a link preview01FetchGET your URL02Readog, twitter, oEmbed03Buildlay out card04Cachereuse copy
Fetch, read, build, cache. Nothing reaches your server until someone pastes or posts the link.
  1. Fetch. The app requests your URL with a plain HTTP GET. Slack's unfurling documentation says its servers must fetch every URL in a message to work out what kind of content it is.
  2. Read. It parses the HTML head. Slack says classic unfurling looks for common Open Graph and X Card metadata. Some apps also follow an oEmbed discovery link, described below.
  3. Build. It maps the values onto its own card layout: big image or small thumbnail, one title line or two, description or none.
  4. Cache. It stores the result so the next share of the same URL does not trigger a new fetch. How long, and how you clear it, depends on the platform.

The parts of a card and the tags behind them

The Open Graph protocol names four required properties for every page: og:title, og:type, og:image and og:url. It lists og:description and og:site_name as optional but generally recommended. Most cards are built from those six.

The parts of a link preview card and the Open Graph tag behind each01Imageog:image02Titleog:title03Descriptionog:description04Site nameog:site_name05Link targetog:url
Five visible parts, five tags. og:type tells the reader what kind of object the page is and rarely shows on the card.
Card partOpen GraphX Card tagoEmbed field
Titleog:titletwitter:titletitle
Descriptionog:descriptiontwitter:descriptionnone
Imageog:imagetwitter:imagethumbnail_url
Site nameog:site_namenone (twitter:site is an account)provider_name
Authorarticle:authortwitter:creator (an account)author_name
Canonical addressog:urlnonenone

X reads its own twitter: tags, and which of them can be left to the Open Graph values is covered in our guide to twitter:card markup on X. For the picture itself, size and crop matter more than anything else, and the recommended share image dimensions are on their own page.

Where does oEmbed fit in?

Open Graph describes a page. oEmbed describes how to embed it. A consumer, such as a chat app or a CMS, sends a GET request to the provider's endpoint with the page URL, and the provider returns JSON or XML with a type (photo, video, link or rich) and fields like title, author and thumbnail. The spec names WordPress and Slack among the services that consume oEmbed to display link information.

Providers make an endpoint discoverable with a link element in the head, or an HTTP Link header:

<link rel="alternate" type="application/json+oembed"
  href="https://example.com/oembed?url=https%3A%2F%2Fexample.com%2Ftown-clock%2F&format=json"
  title="Town clock oEmbed" />

For an ordinary article you rarely need oEmbed; Open Graph does the job. It matters when you want a playable video or an interactive widget to appear in place of a static card. The spec adds a security note for consumers: show provider HTML inside an iframe on another domain, so it cannot read cookies.

Who fetches the page: a server or the sender's phone?

This decides which IP address appears in your logs, whether a firewall rule can block the preview, and when the card is frozen. Only some platforms document it.

PlatformWho fetchesWhat the docs say
SlackSlack's serversIts servers fetch every URL in a message to decide whether and how to unfurl it
WhatsAppThe sender's appWhatsApp crawls the URL on behalf of the sender while the message is being composed
OthersNot documentedCheck each network's own page; do not assume

WhatsApp's link preview guide adds two details worth knowing. The request carries a user agent of the form WhatsApp/2.x.x.x followed by A, I or N for Android, iOS or web, and an Accept-Language header set to the language the recipient selected, if any. Because the fetch happens while the sender types, the card is fixed at that moment; later edits to your tags change only new messages. The app specifics are in our WhatsApp and iMessage preview guide.

There is no common rule. oEmbed responses can carry a cache_age in seconds, but the spec calls it a suggested lifetime that consumers may ignore. Slack's unfurling page does not publish a cache time for classic unfurls. Facebook and LinkedIn keep their own copies and give you a tool to refresh them: Meta's Sharing Debugger and the LinkedIn re-scrape tool. Slack's own behaviour, including how to stop a link unfurling, is in Slack unfurl settings and fixes.

The practical rule: when you change a card, change it on your site, purge your page cache and CDN, then refresh each platform with its own tool. If you replace the image, give it a new file name so caches keyed on the old URL do not keep it.

Check what a preview will read

Before you share a page, look at the tags an app will actually receive. View source shows the server's HTML, which is what a fetcher gets; the browser inspector shows the page after scripts ran, which may not be.

  1. Open the page in a desktop browser

    Use the exact public URL you plan to share, with https and your usual trailing slash.

  2. View the source

    Press Ctrl+U in Chrome, Edge or Firefox on Windows, or Option+Command+U in Chrome on a Mac, to open the raw HTML.

  3. Search for og:

    Press Ctrl+F or Command+F and type og:. Count the og:title, og:description, og:image and og:url lines; each should appear once.

  4. Check the image URL

    Copy the og:image value into a new tab. It should be an absolute https address that opens the picture directly.

  5. Search for twitter: and oembed

    Confirm twitter:card is present, and note any application/json+oembed link.

  6. Paste the source into a checker

    Copy the whole source and paste it into our browser-only card preview tool, which reads the tags locally and fetches nothing.

On WordPress the tags usually come from an SEO plugin or the theme. If two of them print tags, you get duplicates; setting up OG tags in WordPress explains how to keep one source.

What goes wrong

  • Tags added by JavaScript. A fetcher reads the HTML your server sends. Tags injected after load are invisible to it.
  • Relative image paths. /uploads/share.jpg means nothing to an app on another domain. WhatsApp's guide asks for an absolute URL for og:image.
  • Two plugins, two sets of tags. The Open Graph spec says the first tag wins in a conflict, so the order of plugins decides your card.
  • A bot challenge in front of the page. The fetcher gets the challenge page and builds a card from its title.
  • Bare domain names in Slack messages. Slack only unfurls fully qualified URLs, and skips links whose label is the URL without the protocol.
  • Expecting old messages to update. A card already posted keeps the data it was built with.

Check it worked

  • View source shows exactly one og:title, og:description, og:image and og:url.
  • The og:image URL opens the picture directly in a private browser window.
  • og:url matches the canonical URL of the page character for character.
  • A test message to yourself in Slack or WhatsApp shows the image, title and site name you expect.
  • Facebook and LinkedIn's own tools show a scrape time later than your last change.

Sources

Questions

What is a link preview?

A link preview is the card an app shows when someone shares a URL: usually an image, a title, a short description and the site name. The app builds it from tags in your page head, mainly Open Graph, so the site owner controls what appears.

What tags does a link preview use?

Mostly Open Graph: og:title, og:description, og:image, og:url and og:site_name. Slack's documentation says it also reads X Card tags, and some apps use oEmbed when a provider offers it. Add Open Graph first, then twitter:card for X.

Is a link preview generated by the server or the sender's device?

It depends on the app. Slack documents that its servers fetch every URL in a message. WhatsApp documents that it crawls the URL on behalf of the sender while the message is composed. Many apps do not say.

Why does my link preview show old information?

The platform cached an earlier copy. Update your tags, purge your page cache, then refresh the card with the platform's tool, such as Meta's Sharing Debugger. Messages already sent keep the old card, and a changed image needs a new file name.

What is the difference between Open Graph and oEmbed?

Open Graph is a set of meta tags in your page that describe it. oEmbed is an API: an app asks your endpoint for embed data and gets JSON or XML back, which can include playable video or rich HTML instead of a static card.

Share this guide

Hannah Voss, Editor. Checks every guide against a working WordPress install and the networks' current documentation. Last reviewed September 2026.

  1. Adding Open Graph tags in WordPressAdd Open Graph tags to WordPress with an SEO plugin or theme code: the four required tags, image tags, per-post overrides, and how to avoid duplicate tags.7 min read
  2. Open Graph image size: 1200 by 630 and the safe zoneThe right Open Graph image size is 1200 by 630 pixels at a 1.91:1 ratio. Minimums, file limits, formats, and a centre safe zone for square crops.6 min read
  3. Slack link preview: how unfurling works and how to fix itHow Slack builds a link preview: the tags its robot reads, its user agent, the 30 minute cache, how to test, remove or block a preview, and why one fails.10 min read
  4. Link preview checker: test your Open Graph and card tagsPaste a page's HTML to check its Open Graph and X card tags, see mock previews, and find duplicate, missing or relative tags. Runs in your browser only.10 min read
  5. WhatsApp and iMessage link previews: how they are built and how to fix themHow WhatsApp and Apple Messages build link previews from your Open Graph tags, the image sizes each documents, how to test, and why a preview is missing.9 min read