Skip to content
LetterBy 9 min read

A letter to a founder about link previews

18 November 2026

Re: what shows up when someone pastes your link into a chat

Dear founder,

If you have pasted your own product link into a chat and seen a bare address where a picture should be, this letter is for you. Every app that shows a preview sends a robot to your page. The robot does not look at the page the way you do. It reads a few og: tags in the HTML and builds the card from them.

Below: what four of those apps say they want, three ways to see your page as they do, and how to make one card per page from HTML. Where the platforms say nothing, I say so, and I do not guess.

What the robots want

Four tags carry a preview: og:title, og:description, og:url and og:image. The Open Graph protocol calls the title, type, image and url required.[1] LinkedIn lists title, image, description and url as the tags that must exist.[5] WhatsApp wants the title, description and url inside the head, not empty, and the image as an absolute address.[7]

The rules for the picture are where the platforms part ways. Meta allows 8 MB, LinkedIn 5 MB, WhatsApp asks for under 600 KB.[2][5][7] One 1200 by 630 image under 600 KB meets all three. The size chart has the sizes of more platforms. This letter is about the other half: what happens when the tag is missing, wrong or stale.

I cannot show you what each app draws. I have no way to post a link into your apps from a script, and the platform pages mostly describe the rules and not the failures. So the panel below shows each platform’s own page, fault by fault, and marks the cases where that page says nothing. Read on 2026-11-12.

Enclosure 1: what each platform says

Pick a fault on your page

No og:image at all

The page has a title and a description, and no picture tag.

  • Facebook (Meta)Its page does not say

    Not stated. The page names og:image as the tag that sets the picture and says nothing about a page without it.[2]

    User agent: facebookexternalhit/1.1

  • LinkedInIts page says

    og:image is one of the tags that "must exist": title, image, description and url.[5]

  • WhatsAppIts page says

    A page that does not meet the requirements "may risk the link to be not previewed". WhatsApp may try other markup and a small preview, but the page says not to rely on that.[7]

    User agent: WhatsApp/2.x.x.x

  • SlackIts page does not say

    Not stated. Slack looks for oEmbed, Twitter Card and Open Graph tags and draws "some micro-approximation of the content".[8][9]

    User agent: Slackbot-LinkExpanding 1.0

The X card pages we tried (the older developer.x.com cards guides) now redirect to the developer overview, so there is no X page to cite for any row above. X's own docs site sets og:image and twitter:image to one file and twitter:card to summary_large_image.[10]

What the checker printed on a page with this fault

  • /no-image: Everything except og:image

    FAIL no og:image

Three ways to look before your users do

One: ask for the page as a robot does. A page can answer a crawler differently from a browser: a firewall rule, a login wall, a bot filter. WhatsApp names its user agent and says owners can serve it their own markup.[7] Meta tells you to test with its crawler’s user agent.[3] Read the tags in what comes back. If no og: line prints, the robot sees none.

The first 300 KB, as WhatsApp asks for it
curl -sA 'WhatsApp/2.22.20.72 A' https://your-app.example/pricing | head -c 307200 | grep -io '<meta[^>]*og:[^>]*>'

Two: use the platforms’ own tools. Meta’s Sharing Debugger shows the tags its crawler scraped, with errors and warnings, and starts a new scrape.[3] LinkedIn’s Post Inspector refreshes a cached preview.[6] The Slack pages I read name no debugger, so post the link in a private channel.

Three: run a checker on every template. I wrote one for this letter. It loads the page with a browser and with three crawler user agents, reads the tags, fetches the image and compares both with the numbers from the table above.

Enclosure 2: the checker, 97 lines of Node with no dependencies
ogcheck.mjs
// ogcheck.mjs: node ogcheck.mjs <page-url> [<page-url> ...]
// Fetches each page the way four crawlers do, reads its Open Graph tags,
// fetches the og:image and compares both with what the platform docs ask for.
const AGENTS = {
  browser: 'Mozilla/5.0',
  facebook: 'facebookexternalhit/1.1 (+http://www.facebook.com/externalhit_uatext.php)',
  whatsapp: 'WhatsApp/2.22.20.72 A',
  slack: 'Slackbot-LinkExpanding 1.0 (+https://api.slack.com/robots)',
}
const KB = 1024

function size(bytes) {
  // PNG: width and height sit at bytes 16-23. JPEG: scan to a start-of-frame marker.
  if (bytes[0] === 0x89 && bytes[1] === 0x50) return { w: bytes.readUInt32BE(16), h: bytes.readUInt32BE(20) }
  if (bytes[0] === 0xff && bytes[1] === 0xd8) {
    for (let i = 2; i < bytes.length - 9; ) {
      if (bytes[i] !== 0xff) { i++; continue }
      const m = bytes[i + 1]
      if (m >= 0xc0 && m <= 0xcf && m !== 0xc4 && m !== 0xc8 && m !== 0xcc) return { h: bytes.readUInt16BE(i + 5), w: bytes.readUInt16BE(i + 7) }
      i += 2 + bytes.readUInt16BE(i + 2)
    }
  }
  return null
}

function tags(html) {
  const found = {}
  for (const tag of html.match(/<meta\s[^>]*>/gi) ?? []) {
    const key = /(?:property|name)\s*=\s*["']([^"']+)["']/i.exec(tag)?.[1]
    const value = /content\s*=\s*["']([^"']*)["']/i.exec(tag)?.[1]
    if (key && value !== undefined && !(key in found)) found[key] = value
  }
  return found
}

async function get(url, agent) {
  try {
    const res = await fetch(url, { headers: { 'user-agent': AGENTS[agent], accept: '*/*' }, redirect: 'follow' })
    return { status: res.status, type: res.headers.get('content-type') ?? '', body: Buffer.from(await res.arrayBuffer()) }
  } catch (error) {
    return { status: 0, type: '', body: Buffer.alloc(0), error: error.cause?.code ?? error.message }
  }
}

const seenImages = new Map()

for (const url of process.argv.slice(2)) {
  const out = []
  const say = (level, text) => out.push(level + ' ' + text)
  const page = await get(url, 'browser')
  if (page.status !== 200) { say('FAIL', 'page answered ' + (page.status || page.error) + ' to a browser'); console.log(url + '\n' + out.join('\n') + '\n'); continue }

  for (const agent of ['facebook', 'whatsapp', 'slack']) {
    const res = await get(url, agent)
    if (res.status !== 200) say('FAIL', agent + ' crawler gets ' + (res.status || res.error) + ', a browser gets 200')
  }

  const html = page.body.toString('utf8')
  const t = tags(html)
  for (const name of ['og:title', 'og:description', 'og:url', 'og:image']) if (!t[name]) say('FAIL', 'no ' + name)
  const at = page.body.indexOf('og:image')
  if (at > 300 * KB) say('FAIL', 'og:image starts at byte ' + at + ', past the first 300 KB WhatsApp reads')
  if (!t['twitter:card']) say('WARN', 'no twitter:card')
  if (t['og:image'] && !t['og:image:width']) say('WARN', 'no og:image:width / og:image:height (Meta: needed to render on the first share)')

  if (t['og:image']) {
    const absolute = /^https?:\/\//i.test(t['og:image'])
    if (!absolute) say('FAIL', 'og:image is "' + t['og:image'] + '", not an absolute URL (WhatsApp asks for one)')
    const imageUrl = new URL(t['og:image'], url).href
    const img = await get(imageUrl, 'browser')
    if (img.status !== 200) {
      say('FAIL', 'image answered ' + (img.status || img.error))
    } else {
      const dims = size(img.body)
      const kb = Math.round(img.body.length / KB)
      const before = out.length
      if (!['image/png', 'image/jpeg', 'image/gif'].includes(img.type.split(';')[0])) say('WARN', 'image type ' + img.type + ' is not one of the three Meta lists')
      if (img.body.length > 600 * KB) say('FAIL', 'image is ' + kb + ' KB, WhatsApp asks for under 600 KB')
      if (!dims) say('WARN', 'could not read the image size')
      else {
        const { w, h } = dims
        if (w < 200 || h < 200) say('FAIL', w + 'x' + h + ' is under the 200x200 minimum Meta allows')
        else if (w < 600 || h < 315) say('FAIL', w + 'x' + h + ' is under 600x315: Meta shows it much smaller')
        if (w < 401) say('FAIL', 'only ' + w + ' px wide: LinkedIn shows images under 401 px as a thumbnail')
        else if (w < 1200 || h < 627) say('WARN', w + 'x' + h + ' is under the 1200x627 LinkedIn lists as its minimum')
        if (w < 300) say('FAIL', 'under 300 px wide, which WhatsApp asks for')
        if (w / h > 4) say('FAIL', 'wider than 4:1, the WhatsApp limit')
        if (out.length === before) say('PASS', 'image ' + w + 'x' + h + ', ' + kb + ' KB, ' + img.type)
      }
      const other = seenImages.get(imageUrl)
      if (other) say('WARN', 'same image as ' + other + ': every page shares one preview')
      else seenImages.set(imageUrl, url)
    }
  }
  if (!out.some((line) => line.startsWith('FAIL'))) say('PASS', 'no failing check')
  console.log(url + '\n' + out.join('\n') + '\n')
}

The checker on ten stand-in pages

I ran it on 2026-11-12 against a local server that plays one fault per page. The lines are exactly what it printed. A clean page passes; each fault is reported; two pages with one image raise a warning.

What the checker printed for each of ten stand-in pages
PageWhat it doesThe checker printed
/goodTitle, description, url, 1200 x 630 image, size tags, twitter:card
PASS image 1200x630, 4 KB, image/png
PASS no failing check
/no-imageEverything except og:image
FAIL no og:image
/relativeog:image is /img/good.png
FAIL og:image is "/img/good.png", not an absolute URL (WhatsApp asks for one)
PASS image 1200x630, 4 KB, image/png
/tinyThe image is 300 x 157
FAIL 300x157 is under the 200x200 minimum Meta allows
FAIL only 300 px wide: LinkedIn shows images under 401 px as a thumbnail
/heavyA 1200 x 630 PNG of random noise, 2216 KB
FAIL image is 2216 KB, WhatsApp asks for under 600 KB
/missing-fileog:image points at a file that answers 404
FAIL image answered 404
/lateAbout 480 KB of inline style before the meta tags
FAIL og:image starts at byte 480260, past the first 300 KB WhatsApp reads
PASS image 1200x630, 4 KB, image/png
/blocks-botsAnswers 403 to the WhatsApp, Facebook and Slack user agents
FAIL facebook crawler gets 403, a browser gets 200
FAIL whatsapp crawler gets 403, a browser gets 200
FAIL slack crawler gets 403, a browser gets 200
PASS image 1200x630, 4 KB, image/png
/shared-aA clean page with its own image
PASS image 1200x630, 4 KB, image/png
PASS no failing check
/shared-bA second clean page with the same image as /shared-a
PASS image 1200x630, 4 KB, image/png
WARN same image as /shared-a: every page shares one preview
PASS no failing check

What this run does not show

The checker applies the numbers the platform pages print. It cannot tell you what an app draws, and the stand-in server is one machine playing each fault once. The WhatsApp, Facebook and Slack names it sends are the ones their pages document; I found no LinkedIn user agent on the help pages I read, so it sends none.

Why a fix does not show

You fix the tag, share the link again, and the old preview is back. That is a cache, and each platform keeps its own.

  • Meta caches an image by its address. A replaced file keeps the old preview until the address changes. Use a new file name, then re-scrape in the Sharing Debugger or with the Graph API.[2] Meta also says not to delete the old image, because earlier shares may still point at it.
  • LinkedIn may show a cached image. Post Inspector refreshes it, and only for new posts. Posts that already carry the link keep the old preview.[6]
  • Slack caches what its robot fetched “for around 30 minutes”.[8]

The rule that follows: name the image after its content, such as build-time-3f9a1c.png, and never overwrite a file that was shared. Both help pages from LinkedIn are labelled as last updated three years ago, so check the behaviour once on your own link.

One card per page, from HTML

The commonest fault is not a broken tag. It is one image on every page, so a link to your pricing page looks like a link to your home page. The checker’s last row finds it. The fix is a card made for each page, and HTML is a good way to make one: you design it once in a file you can open in a browser, and fill in a title for each page.

The docs have the whole recipe in Open Graph images from HTML. The short form: send the card HTML with a 1200 by 630 window, get a PNG of exactly that size, and save it.

One card from one request
jq -n --rawfile html card.html \
  '{html: $html, viewport_width: 1200, viewport_height: 630, format: "png"}' \
| curl -X POST "https://curlshot.com/api/v1/screenshot" \
    -H "X-Access-Key: YOUR_ACCESS_KEY" \
    -H "Content-Type: application/json" \
    -d @- \
    --output og-card.png

Do not point og:image at the API. A POST cannot be written as a link, and stored files expire. Render the card when the page is published, save the bytes under a name that changes with the title, and serve the file yourself.

Save the card under a new name
import { createHash } from 'node:crypto'
import { mkdir, writeFile } from 'node:fs/promises'

// renderCard(post) sends the card HTML and returns the PNG bytes.
export async function saveCard(post) {
  const image = await renderCard(post)
  const hash = createHash('sha256').update(post.title + post.author).digest('hex').slice(0, 6)
  const path = 'og/' + post.slug + '-' + hash + '.png'

  await mkdir('public/og', { recursive: true })
  await writeFile('public/' + path, image)
  return path // store this with the post, and put it in og:image
}

Then the tags for that page. The size tags let Meta draw the image on the first share without fetching it first.[2]

In the head of the page
<meta property="og:title" content="How we cut our build time in half">
<meta property="og:description" content="What we changed, and what it saved.">
<meta property="og:url" content="https://your-app.example/blog/build-time">
<meta property="og:image" content="https://your-app.example/og/build-time-3f9a1c.png">
<meta property="og:image:width" content="1200">
<meta property="og:image:height" content="630">
<meta property="og:image:alt" content="How we cut our build time in half">
<meta name="twitter:card" content="summary_large_image">

How long can a title be?

A card made from data breaks when the data is long. I put the card template from the docs guide into Chromium at 1200 by 630 and fed it 12 title lengths, cut at a word from one sentence. Each bar shows where the text block sits on the card.

  • 20 chars204 to 426 px (inside) clamped: ends 426
  • 36 chars164 to 466 px (inside) clamped: ends 466
  • 59 chars125 to 505 px (inside) clamped: ends 505
  • 78 chars125 to 505 px (inside) clamped: ends 505
  • 98 chars85 to 545 px (inside) clamped: ends 505
  • 108 chars85 to 545 px (inside) clamped: ends 505
  • 115 chars46 to 584 px (in the padding) clamped: ends 505
  • 140 chars6 to 624 px (in the padding) clamped: ends 505
  • 155 chars6 to 624 px (in the padding) clamped: ends 505
  • 179 chars-34 to 664 px (cut off) clamped: ends 505
  • 199 chars-73 to 703 px (cut off) clamped: ends 505
  • 217 chars-73 to 703 px (cut off) clamped: ends 505
Each bar is the block of text, from the top of the site name to the bottom of the byline, in pixels down the 630 px card. The template centres its text, so a long title grows up and down. The thin lines mark the 80 px padding at each end; the thick lines are the card edges.

Up to 108 characters (four lines) the block stays inside the padding, from 85 to 545 px. At 115 it reaches into the padding on both sides, at 140 it is 6 px from each edge, and at 179 the site name at the top and the byline at the bottom are both cut off. There is a second break: a word of 45 letters with no place to break made the card 1823 px wide. This one line holds the title to three lines and lets a long word wrap. With it, every row ends at 505 px, and the long word stays inside 1200 px.

Add to the card's CSS
h1 { display: -webkit-box; -webkit-line-clamp: 3; -webkit-box-orient: vertical; overflow: hidden; overflow-wrap: anywhere; }

That is the card side. The Open Graph image generator page has the request in a box, and HTML to image covers any other card or template. A repeat of the same request is served from the cache and not counted; the pricing page lists the free plan. For a pile of templates to start from, see six HTML to image templates.

P.S. Six lines before launch

  1. Run the checker on five real pages: home, pricing, a blog post, a docs page, a signup page. Fix every FAIL.
  2. Look at the WARN lines. Two pages with the same image are the usual one.
  3. Run the curl line with the WhatsApp user agent on one page. If no og: tags print, the robot sees none.
  4. Paste one address into the Sharing Debugger and into Post Inspector, and read what they report.
  5. Post one link in a private Slack channel. Check it again after 30 minutes if you changed anything.
  6. Give every changed image a new file name. Never overwrite one that was shared.

What I did not check

No app was sent a link in this run, so nothing here says what any app draws; the panel states what each platform’s own page says. X has no page I could open that explains its cards. The stand-in pages ran on one machine, and the card test used one template in one browser. Platform pages change; the date on each source is the day I read it.

Yours,

CurlShot

Questions people ask

What does a link preview show when og:image is missing?

It depends on the app, and the platforms' own pages say little. LinkedIn lists og:image among the tags that must exist. WhatsApp says a link that misses the requirements may not be previewed, and that it may fall back to a small preview, which it says not to rely on. The Meta and Slack pages do not say. Read on 2026-11-12.

How do I check what Facebook, LinkedIn, WhatsApp and Slack see on my page?

Load the page with curl and each crawler's user agent, then read the og: tags in the answer. Add the Sharing Debugger for Meta, Post Inspector for LinkedIn, and a test post in a private Slack channel. A short checker script can also compare the tags and the image with each platform's numbers, as the one in this letter does.

Why does my link preview still show the old image?

The preview is cached. Meta caches an image by its address, LinkedIn keeps a cached preview until Post Inspector refreshes it, and Slack caches for about 30 minutes. Publish the new image under a new file name, then re-scrape or refresh.

What size should an og:image be?

Use 1200 by 630 pixels, as a PNG or JPEG under 600 KB. That meets Meta's advice for high resolution screens, LinkedIn's 1200 by 627 minimum and WhatsApp's 600 KB and 300 px limits. The sizes of other platforms are in the size chart article linked below.

Can every page of my site have its own og:image?

Yes. Design the card as HTML, put each page's title in it, render it at 1200 by 630 pixels, save the file under a new name per title, and point that page's og:image at it. CurlShot renders the card from HTML with one request; a repeat of the same request is served from the cache and not counted.

Sources

  1. [1]ogp.me, The Open Graph protocol. Checked .
  2. [2]Meta for Developers, Images in Link Shares. Checked .
  3. [3]Meta for Developers, A Guide to Sharing for Webmasters. Checked .
  4. [4]Meta for Developers, Sharing best practices. Checked .
  5. [5]LinkedIn Help, Make your website shareable on LinkedIn. Checked .
  6. [6]LinkedIn Help, Use Post Inspector to refresh URL. Checked .
  7. [7]WhatsApp Business Platform, Meta for Developers, Link Previews. Checked .
  8. [8]Slack, Slack Robots. Checked .
  9. [9]Slack Developer Docs, Unfurling links in messages. Checked .
  10. [10]X, X Developer Platform overview (the page the old cards guides now redirect to). Checked .

Screenshot any page in one step

Paste an address into CurlShot and download the screenshot. A free account gives you 100 screenshots every month. No card needed.

A letter to a founder about link previews | CurlShot