Link Preview API

Previews that are right on sites that render themselves.

A link-preview API that runs a real browser. On a single-page app the og: tags are written by JavaScript, so a fetch-and-parse preview reads the shell's defaults and every URL on the site previews identically. This one reads the page after it has rendered.

display:none — still in the DOM detached before reading
93%renders succeedacross a 29-URL benchmark
69%are actually usablethe gap nobody quotes
1 / 29blocked by bot protection7 ruined by consent walls
~2smedian renderp50, viewport capture

Why a browser, and why it has to remove rather than hide

Modern extraction runs a real browser, because a plain fetch returns a shell that JavaScript was supposed to fill in. But once the browser has run, the consent dialog is in the document — and hiding it with display:none keeps it out of a screenshot, not out of the DOM. So it comes back in the text. Measured on zoom.com in August 2026: a leading browser-based markdown API returned 51 fragments of cookie-consent copy, including the full Cookie Preference Center. The same page through /v1/markdown returned none, because the nodes are detached before a word is read.

Reading https://www.zoom.com Fragments of consent copyWhat you actually get
A plain fetch + a readability parser0…and no article either: the page is a shell until JavaScript runs
A leading browser-based markdown API51including the full “Cookie Preference Center” and the OneTrust logo
rendershed /v1/markdown01 overlay node detached before extraction

Measured August 2026, and it will drift as everyone's pipelines change — the method is a regex for consent wording over each tool's own output, which is as reproducible as it is crude. Run it yourself before believing it.

Cosmetic is not enough for text

Suppression on the capture path is a stylesheet: the consent dialog stops being painted, which is the whole job for a screenshot. It is still a node, so page.content(), textContent and every HTML parser downstream still see it. These endpoints detach the tagged nodes first, and tell you how many in suppressed.stripped.

Where this does not help

Worth saying plainly. Some consent managers render in a cross-origin iframe — Sourcepoint, which fronts the Guardian and the BBC — and no extractor can read inside one, so their copy was never going to reach your text. And when main_only is on, the article-finding step already drops most page furniture. The gap this closes is inline consent managers, whole-document reads, and pages with no clear article body.

It never clicks Accept

Declining on your behalf for a throwaway read is defensible. Agreeing on your behalf is not. Reject buttons that are really subscription funnels are recognised by their own label and skipped in favour of hiding — the Guardian's is exactly that, which is why it comes back marked ~sourcepoint.

It sees what JavaScript built

A fetch returns what the server sent, which on most of the web is a shell. This runs the page, waits for the network to settle, and reads the document that resulted — the same navigation a screenshot gets, because it is the same fleet.

One render, one allowance

The same key, the same quota and the same subscription as a screenshot or a PDF. There is no separate plan for text, and a cached call is free because it cost us a disk read.

One call, no signup POST /v1/metadata application/json

Anonymous calls run at 40 an hour against your address. A free key raises that and works from anywhere.

# No key needed. Try it on a site that renders itself — the og: tags
# a plain fetch sees there are the shell's, identical on every URL.
curl -X POST https://shots.rendershed.com/v1/metadata \
  -H "Content-Type: application/json" \
  -d '{"url": "vercel.com"}'
const res = await fetch("https://shots.rendershed.com/v1/metadata", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    ...(process.env.RENDERSHED_KEY && {
      "X-API-Key": process.env.RENDERSHED_KEY,
    }),
  },
  body: JSON.stringify({ url: "https://example.com/post" }),
});

const { metadata } = await res.json();
// Everything is resolved absolute, so it drops straight into a card.
render({
  title: metadata.title,
  description: metadata.description,
  image: metadata.image?.url,
  favicon: metadata.icons[0]?.href,
  site: metadata.site_name,
});
import os, requests

meta = requests.post(
    "https://shots.rendershed.com/v1/metadata",
    headers={"X-API-Key": os.environ["RENDERSHED_KEY"]},
    json={"url": "https://example.com/post"},
    timeout=90,
).json()["metadata"]

print(meta["title"])
print(meta["description"])
print((meta["image"] or {}).get("url"))

What comes back

Trimmed from a real response through this API.

{
  "url": "https://vercel.com",
  "metadata": {
    "title": "Agentic Infrastructure - Vercel",
    "description": "The autonomous stack for every app and agent.",
    "site_name": "Vercel",
    "type": "website",
    "canonical": "https://vercel.com/",
    "lang": "en",
    "image": { "url": "https://.../og-home.png", "alt": "", "width": null, "height": null },
    "icons": [{ "href": "https://vercel.com/favicon.ico", "sizes": "", "rel": "icon" }],
    "feeds": [],
    "oembed": null
  }
}

Parameters

NameTypeDefaultDescription
url stringrequiredThe page to inspect. http and https only.
device enumiphone, android or ipad.
overlay_mode enumdismissoff, hide or dismiss.

Errors, response headers and the signed-URL scheme are the same for every product — they live in the reference.

On the same key

Five outputs, one account, one quota. Every call costs one render whichever path you use.

Get a key