Your files never leave your device. All processing happens locally in your browser.
How do I preview my Facebook / LinkedIn / X share card and validate my Open Graph (og:) tags — without uploading my page to a server?
Open AnyTool’s Open Graph Checker, paste your page’s HTML source (View Source / Ctrl+U) — or fill the small og:title / og:type / og:image / og:url / og:description / og:site_name form — and it parses every og:* and twitter:* meta tag and renders a LIVE share-card preview the way Facebook, LinkedIn and X show it: a 1.91:1 image (with a graceful fallback when the image URL can’t load), the title, the description and the UPPERCASE domain, applying the same OG → <title> / <meta description> and twitter: → og: fallbacks the platforms use. It then VALIDATES against the Open Graph protocol and the platforms’ image rules — the four required tags (og:title, og:type, og:image, og:url), the recommended ones (og:description, og:site_name, og:locale, og:image:alt and og:image:width/height), and image specs (absolute https, ~1200×630, Facebook’s 600×315 large-card and 200×200 minimums, 1.91:1 aspect) — with a clear pass / warn / fix for each, plus a raw parsed-tags table. Everything runs in your browser, so your HTML is NEVER uploaded — safe for staging pages, unlike online debuggers that fetch and CACHE your page on a server. Honest caveat: each platform renders its card differently and caches aggressively, so after editing tags force a re-scrape in Facebook’s Sharing Debugger / LinkedIn’s Post Inspector; this previews + lints, it is not the official platform renderer.
Live Facebook / LinkedIn / X share-card preview from your og: and twitter: tags (1.91:1 image, title, description, UPPERCASE domain)
Validates the 4 required + recommended OG tags and image specs (absolute https, ~1200×630, Facebook 600×315 / 200×200 minimums, 1.91:1)
Paste full page HTML or fill a small OG form; raw parsed-tags table with og: / twitter: fallbacks shown
100% client-side — your HTML and tags are never uploaded; safe for staging pages, works offline once cached
Honest: platforms render and cache cards differently — force a re-scrape after editing; your browser can’t fetch most live URLs (CORS), so paste source; not the official platform renderer
What is
Open Graph tags (og:) and the social share card
Open Graph is a protocol (originally from Facebook, now read by LinkedIn, X and others) that uses <meta property="og:*"> tags in a page’s <head> to control how the page looks when its link is shared: og:title, og:type, og:image and og:url are required, and og:description, og:site_name, og:locale and og:image:width/height/alt are recommended. From these tags each platform builds a SHARE CARD — a preview image (ideally an absolute https URL around 1200×630, a 1.91:1 ratio), a headline, a summary and the domain. X also reads twitter:* Card tags and falls back to the og: equivalents when they are absent. An Open Graph checker parses these tags, previews the resulting card and validates the tags and image against the protocol and the platforms’ documented rules, since a missing or undersized og:image sharply lowers how a shared link performs.
SEO & Web
Related terms
Open Graph protocolog:imageTwitter CardShare cardSharing DebuggerPost InspectorSocial meta tagsLink preview
Frequently Asked Questions
Because every platform caches your share card aggressively. After you change your og: tags, force a re-scrape in Facebook’s Sharing Debugger and LinkedIn’s Post Inspector — that re-fetches your page and refreshes the cached card.
Facebook, LinkedIn and X each fetch your page once, build a share card from your og: tags and then CACHE it — sometimes for days — so editing your tags does not update the preview until they re-fetch. To refresh it, paste your URL into Facebook’s Sharing Debugger and click “Scrape Again”, use LinkedIn’s Post Inspector, and re-share on X; that forces each platform to re-scrape and rebuild the card. This Open Graph Checker previews and lints the tags you paste so you can get them right BEFORE you publish and re-scrape, but it cannot clear a platform’s cache — only the platform’s own debugger can. It is also explicit that each platform renders the card slightly differently (image crop, how much description shows), so treat the preview as an accurate approximation, not a pixel-exact copy of any one network.
Use an absolute https URL, ideally about 1200×630 pixels (a 1.91:1 ratio). Facebook needs at least 600×315 to show the large card and rejects images under 200×200, and the file should stay under ~8 MB.
The recommended share image is an ABSOLUTE https URL (relative paths fail — the platforms cannot resolve them) sized around 1200×630 pixels, which is the 1.91:1 aspect ratio Facebook, LinkedIn and X crop to. Facebook shows the large, attention-grabbing card only when the image is at least 600×315; below that it falls back to a small thumbnail, and it refuses images under 200×200 entirely. Declare og:image:width and og:image:height so the card renders instantly at the right shape without a layout flash, add og:image:alt for accessibility, and keep the file under about 8 MB. This checker validates all of that: it flags a missing or relative or http (non-https) image, warns when declared dimensions are too small or off the 1.91:1 ratio, and confirms when the image is correct.
Open Graph (og:) tags are read by Facebook, LinkedIn and most platforms; Twitter Card (twitter:) tags are X-specific. The only strictly required Twitter tag is twitter:card — X falls back to your og: tags for the title, description and image when the twitter: ones are missing.
Open Graph tags (og:title, og:type, og:image, og:url, og:description, og:site_name and so on) are the broadly supported standard that Facebook, LinkedIn, Slack, WhatsApp and most networks read. X (Twitter) reads its own twitter:* Card tags, but the only one strictly required is twitter:card (use summary_large_image for a big-image preview); for the title, description and image, X falls back to your og:title, og:description and og:image when the twitter: equivalents are absent. So in practice a complete set of og: tags plus twitter:card covers every major platform. This tool validates both: it lints the Open Graph tags AND the Twitter Card tags (showing where X will fall back to og:), and previews both a Facebook/LinkedIn-style link card and an X/Twitter card.
No. Your HTML is parsed entirely in your browser with plain JavaScript — nothing is fetched, uploaded, logged or stored, and no page is crawled. That makes it safe for staging or unreleased pages.
The Open Graph Checker is 100% client-side. The page source (or OG form) you paste is parsed locally with the browser’s DOMParser, and the previews and validation are built on your device — nothing is fetched, uploaded, logged or stored on a server, and no URL is crawled. That makes it safe for staging, unreleased or internal pages you do not want to expose, unlike online OG debuggers that fetch your page and cache it on their servers. Because the browser cannot fetch most live URLs directly (cross-origin / CORS) and the tool uses no server proxy, you paste your source rather than a URL. It works offline once cached as a PWA, supports dark mode and mobile with a sticky action bar, and closing the tab discards everything you entered.
Detailed Explanation
📖How It Works
What the Open Graph Checker Parses, Previews and Validates
The Open Graph Checker answers one practical question: when this page’s link is shared, what will the card look like, and are the og: tags correct? The user pastes the page’s HTML source (View Source / Ctrl+U) — or fills a small form of the core tags (og:title, og:type, og:image, og:url, og:description, og:site_name) — and the shared engine socialMetaEngine.ts parses every og:* and twitter:* meta tag (plus the <title>, <meta name="description"> and <link rel="canonical"> used as fallbacks). From that it builds a live SHARE-CARD PREVIEW the way Facebook and LinkedIn render it — a 1.91:1 image (with a graceful placeholder when the URL can’t load), the title, the description and the UPPERCASE domain — plus an X/Twitter card, applying the platforms’ real fallbacks (og:title → <title>, og:description → meta description, and twitter:* → og:*). It then VALIDATES the tags against the Open Graph protocol and the platforms’ documented image rules and reports a clear pass / warn / fix for each, alongside a raw parsed-tags table. Everything runs in the browser with the DOMParser API — no upload, no crawl.
Parses every og:* and twitter:* tag (plus title, meta description and canonical fallbacks) with the browser DOMParser
Builds live Facebook / LinkedIn / X share-card previews with a 1.91:1 image and a graceful fallback when it can’t load
Applies the real platform fallbacks: og:title → <title>, og:description → meta description, twitter:* → og:*
Validates the 4 required + recommended OG tags and image specs with a per-tag pass / warn / fix
All parsing, preview and validation is pure client-side JavaScript — no server call, no CDN, no upload, no crawl
⚙️Methodology
How the Tags Are Validated and the Share Card Is Modelled
The reusable engine socialMetaEngine.ts holds the Open Graph rules as data: OG_REQUIRED (og:title, og:type, og:image, og:url), OG_RECOMMENDED (og:description, og:site_name, og:locale, og:image:width/height/alt) and SOCIAL_LIMITS (recommended ~1200×630 at a 1.91:1 aspect, Facebook’s 600×315 large-card threshold and 200×200 minimum, and title/description length budgets). parseSocialMeta(html) prefers DOMParser and falls back to a regex scan, returning og and twitter dictionaries (first occurrence wins, like a crawler), the flat tag list and the fallbacks. validateOpenGraph(meta) checks each required tag, flags an og:image that is missing, relative or http rather than absolute https, warns when declared dimensions are below the minimums or off the 1.91:1 ratio, and checks title/description length — returning issues sorted error → warn → info → ok with pass/warn/fix counts. validateTwitterCard(meta) does the same for twitter:* and shows where X falls back to og:. buildShareCardModel(meta) and buildTwitterCardModel(meta) resolve the title, description, image, domain (host without protocol/www) and site name the way the platforms do, with hasRenderableImage true only for an absolute https URL, and the page renders the cards from those models with an onError image fallback. The same engine powers the sibling Twitter Card Validator, so both share one source of truth.
socialMetaEngine.ts exports parseSocialMeta, validateOpenGraph, validateTwitterCard, buildShareCardModel, buildTwitterCardModel and analyzeSocialMeta
OG_REQUIRED / OG_RECOMMENDED and SOCIAL_LIMITS encode the protocol and Facebook’s image rules as data
Parsing prefers DOMParser with a regex fallback; first-occurrence-wins, like a crawler reads the page
Share-card models resolve title / description / image / domain / site name with the platforms’ og: and twitter: fallbacks
⚠️Limitations
A Preview, Not the Platform: Each Network Renders and Caches Differently
The tool is explicit that it PREVIEWS and LINTS the tags you paste rather than being the platforms’ official renderer, for three honest reasons. First, EACH PLATFORM RENDERS ITS CARD DIFFERENTLY — Facebook, LinkedIn and X use different image crops, fonts and amounts of description — so the preview is an accurate approximation, not a pixel-exact copy of any one network. Second, PLATFORMS CACHE THE CARD AGGRESSIVELY: a network fetches your page once, builds the card from your og: tags and caches it for days, so after you edit your tags the old card persists until you force a re-scrape — paste your URL into Facebook’s Sharing Debugger and click “Scrape Again”, use LinkedIn’s Post Inspector, and re-share on X. Third, YOUR BROWSER CANNOT FETCH MOST LIVE URLs directly because of the cross-origin (CORS) policy, and the tool deliberately uses NO server proxy so your page stays private; the optional “try to fetch” box only works for CORS-enabled or same-origin pages, so you paste your page source instead. The guidance is therefore to fix the tags here BEFORE publishing, use an absolute https og:image around 1200×630, and then confirm and refresh the live card in each platform’s own debugger.
Each platform renders its share card differently (crop, fonts, description length) — the preview is an approximation
Platforms cache the card for days; after editing tags, force a re-scrape in Facebook’s Sharing Debugger and LinkedIn’s Post Inspector
Browsers cannot fetch most live URLs (CORS) and the tool uses no server proxy, so paste your page source
Use an absolute https og:image, ideally ~1200×630 (1.91:1), so every platform can load and crop it correctly
This previews + lints — it is not the official platform renderer; confirm the live card in each platform’s debugger
🔒Privacy & Security
Why Checking Open Graph Tags In-Browser Is a Privacy Win
Most online Open Graph debuggers work by FETCHING your URL on their server and caching the result, which exposes unreleased pages and stores a copy of your page on a third party. The Open Graph Checker instead runs entirely on the user’s device: the HTML (or OG form) you paste is parsed with the browser’s DOMParser and the previews and validation are computed locally; nothing is fetched, uploaded, logged or stored, and no page is ever crawled. That makes it safe to check og: tags on STAGING, unreleased or internal pages before launch — exactly the pages you would not want a server-side debugger to fetch and cache. It works offline once cached as a PWA, supports dark mode and mobile with a sticky Check / Copy bar, has exactly three ad slots, and adds NO new dependency — the parsing, validation and share-card modelling live in the small, reusable socialMetaEngine.ts, which the sibling Twitter Card Validator imports so both tools share one well-typed source of truth.
HTML and OG tags are parsed and previewed locally and never uploaded — no server, no CDN, no crawl
Safe for staging / unreleased pages, unlike online debuggers that fetch and cache your page server-side
Works offline once cached; closing the tab discards your data
No new dependency — parsing, validation and share-card modelling live in the reusable socialMetaEngine.ts, shared with the Twitter Card Validator
Dark mode and mobile support with a sticky Check / Copy bar; exactly three ad slots
Open Graph checking: in-browser (AnyTool) vs typical online OG debuggers
States platforms render & cache differently; not official
Often implies it is the live card
Cost / signup
Free, no signup
Often gated or ad-heavy
AnyTool parses the page HTML (or OG form) you paste entirely in your browser with the DOMParser API and uploads nothing, so it is safe for staging pages — unlike online OG debuggers that fetch and cache your URL on a server. It previews Facebook / LinkedIn / X share cards and validates the four required OG tags, the recommended ones and the image specs (absolute https, ~1200×630, Facebook’s 600×315 large-card and 200×200 minimums, 1.91:1). Honest caveat: each platform renders and caches its card differently, so after editing tags force a re-scrape in Facebook’s Sharing Debugger / LinkedIn’s Post Inspector; your browser can’t fetch most live URLs (CORS) and there is no server proxy, so paste your source; this previews + lints and is not the official platform renderer. Comparison as of June 2026.
