UseToolSuite UseToolSuite

Open Graph Preview

Preview how your web page looks when shared on Facebook, Twitter/X, LinkedIn, and WhatsApp. Audit OG tags, get a score out of 100, and generate optimized meta tags — free and instant.

Last updated

Open Graph Preview is a free, browser-based tool from UseToolSuite's Generator Tools collection. All processing happens locally on your device — your data is never uploaded to any server. Use the tool below, then scroll down for detailed documentation, frequently asked questions, and related resources.

Advertisement

Open Graph Tags

0 / 60
0 / 160

Twitter Card

Live Previews

Google Search

Page Title

https://example.com

Your description will appear here...

Facebook / LinkedIn

EXAMPLE.COM

Page Title

Your description here...

Twitter / X

Page Title

Your description...

example.com

WhatsApp

Page Title

Your description here...

example.com

What is the Open Graph Previewer?

The Open Graph Previewer is a fast, reliable tool that visualizes how your website links will appear when shared across social media platforms and messaging apps. Without proper Open Graph (OG) tags, links often display missing images or truncated text, hurting click-through rates. This tool fetches the meta tags from any public URL and renders high-fidelity previews for Twitter, Facebook, LinkedIn, and Discord. It is an essential utility for frontend developers and SEO specialists who need to validate their `og:image` and `twitter:card` implementations before launching a campaign.

How does it work?

When you submit a URL, the tool typically uses a lightweight backend proxy (or serverless function) to fetch the target HTML—bypassing CORS restrictions. It then parses the `` of the document to extract Open Graph and Twitter meta tags. The frontend takes these extracted values and populates CSS-styled components that mimic the exact layout algorithms used by major social networks.

Common use cases

1. Testing how a new blog post will look when shared on Twitter or LinkedIn before officially publishing it.
2. Debugging issues where a shared URL displays an outdated thumbnail image or incorrect title text.
3. Verifying that dynamically generated `og:image` tags in frameworks like Next.js are rendering correctly in production.

When your URL is pasted into Facebook, LinkedIn, Slack, iMessage, or X, the platform generates a preview card from your Open Graph tags. Get them right and your link looks professional and clickable; get them wrong and it shows a broken image, a truncated title, or content scraped from the wrong part of the page. Since that card is often the only thing a person sees before deciding to click, it’s worth auditing — this tool previews how the share will render across platforms and scores your tag setup.

The tags that drive the card

TagControls
og:titleThe headline of the card
og:descriptionThe supporting line
og:imageThe preview image (1200×630)
og:urlThe canonical link
twitter:cardTwitter’s layout (summary_large_image)

Twitter falls back to OG tags when its own aren’t present, so at minimum add twitter:card; everything else can ride on Open Graph.

Caches are why your update “didn’t work”

Platforms cache previews aggressively — Facebook for roughly a month, others for days. So after you fix your tags, the old preview can persist, making it look like nothing changed. The fix is to force a re-scrape through each platform’s debugger (Facebook Sharing Debugger, LinkedIn Post Inspector), and optionally add a ?v=2 cache-buster to the og:image URL. Always re-scrape after editing OG tags.

Audit before you publish

Use the Parse HTML mode to paste a page’s <head> and get a full report: which OG, Twitter, and standard meta tags are present, a score out of 100, and specific warnings (title too long, missing image, no canonical). This is the fast way to catch problems before a page goes live and gets shared with a broken card. To generate the tags in the first place, pair this with the Meta Tag Generator. Everything runs locally — the tool works on the markup you provide and makes no external requests.

How helpful was this tool?

Click to rate

Advertisement

Key Concepts

Essential terms and definitions related to Open Graph Preview.

Open Graph Protocol

A protocol originally created by Facebook in 2010 that enables any web page to become a rich object in a social graph. Open Graph uses meta tags in the HTML <head> to define the title, description, image, URL, and type of a page. When a URL is shared on social media, the platform reads these tags to generate a rich link preview. The four required OG properties are og:title, og:type, og:image, and og:url.

Twitter Card

Twitter's proprietary meta tag system for controlling link previews on Twitter/X. There are four card types: "summary" (small image + text), "summary_large_image" (large banner image + text), "app" (app download card), and "player" (inline video/audio). Twitter falls back to Open Graph tags if Twitter-specific tags are not present, but the twitter:card tag must be explicitly set to choose the preview format.

Canonical URL

The preferred URL for a page when it is accessible at multiple URLs. The canonical URL is specified with <link rel="canonical" href="..." /> and tells search engines which URL to index and display in search results. It is also used by social platforms to associate all shares of the same content, regardless of URL parameters or tracking codes, with a single canonical link.

Social Graph

A map of connections between entities (people, pages, content) on a social platform. When you share a URL with Open Graph tags, the platform creates a "node" for that URL in its social graph, linking it to your profile and to anyone who interacts with the share. Rich metadata (title, image, description) makes this node more engaging and clickable, which increases reach through the platform's algorithm.

Frequently Asked Questions

What are Open Graph tags and why do I need them?

Open Graph (OG) tags are HTML meta tags that control how your page appears when shared on social media platforms like Facebook, LinkedIn, Twitter/X, and WhatsApp. Without OG tags, these platforms guess what to display — often showing the wrong image, a truncated title, or no description. Properly configured OG tags can increase click-through rates by 2-3x on social shares by ensuring your content looks professional and engaging in every link preview.

What is the optimal og:image size?

The optimal og:image size is 1200x630 pixels (1.91:1 aspect ratio). This size displays correctly across all major platforms: Facebook uses 1200x630 for link previews, LinkedIn uses the same ratio, and Twitter's "summary_large_image" card displays it well. For Twitter's smaller "summary" card, a 600x600 square image works better. Always use HTTPS URLs for images and keep file sizes under 5MB.

Why do I see an old image/title when I share my updated page?

Social platforms cache link previews aggressively. Facebook caches previews for about 30 days, Twitter for about 7 days. To force a refresh: use Facebook's Sharing Debugger (developers.facebook.com/tools/debug/) to scrape new data, use Twitter's Card Validator (cards-dev.twitter.com/validator) to refresh the cache, and for LinkedIn, use the Post Inspector (linkedin.com/post-inspector/). Always clear the cache after updating OG tags.

Do I need both Open Graph and Twitter Card tags?

Twitter/X supports Open Graph tags as a fallback, but for optimal control, include both. Twitter-specific tags (twitter:card, twitter:title, twitter:description, twitter:image) take priority over OG tags on Twitter. The most important Twitter-specific tag is twitter:card, which determines the preview format: "summary" shows a small image, while "summary_large_image" shows a large banner image. If you only implement one set, use Open Graph — it has the broadest platform support.

What does the Parse HTML mode do?

Parse HTML mode lets you paste the <head> section of any HTML page, and the tool will extract all Open Graph tags, Twitter Card tags, standard meta tags, canonical URLs, and favicons. It then scores your implementation out of 100, shows warnings for potential issues (like titles that are too long), and provides specific recommendations for missing tags. This is useful for auditing existing pages before publishing.

Does this tool fetch live URLs?

No. This tool does not fetch external URLs — it works entirely with data you provide (either manual input or pasted HTML). This means no network requests are made and your data stays private. To test a live URL, view the page source in your browser (Ctrl+U), copy the <head> content, and paste it into the Parse HTML tab.

Why does my link preview show the wrong image, or no image at all?

Five usual causes, in rough order of frequency: (1) the og:image URL is RELATIVE, not absolute — it must be a full https:// URL, since the social platform fetches it from its own servers and can't resolve a relative path; (2) the image is too small — Facebook needs at least 200×200, and under 600×315 it won't render as a large card; (3) CACHED data — the platform scraped an old version and is showing it (use the platform's debugger to re-scrape); (4) MISSING tags — no og:image at all, so the platform guesses from page content; or (5) the image is behind authentication or blocked by robots/hotlink protection, so the scraper can't fetch it. Run your page through this previewer (or paste the <head>) to spot which tag is missing or malformed before you publish.

What's the safest single og:image size for all platforms?

1200×630 pixels (a 1.91:1 aspect ratio). This is the size Facebook and LinkedIn recommend for a large link-preview card, and Twitter/X's 'summary_large_image' card renders it well too — so one image at 1200×630 covers every major platform without per-platform variants. Keep the file under ~5MB, use HTTPS, and put any important text safely inside the center (platforms can crop edges slightly on some layouts). If you also want Twitter's smaller square 'summary' card, a 600×600 image works there, but for a single do-everything asset, 1200×630 is the answer. Design it as a deliberate share graphic — a compelling OG image measurably increases click-through on social.

Troubleshooting & Technical Tips

Common errors developers encounter and how to resolve them.

Facebook shows wrong image despite correct og:image tag

Facebook aggressively caches link previews. Use the Facebook Sharing Debugger (developers.facebook.com/tools/debug/) to force a re-scrape. Also verify that your og:image URL is absolute (starts with https://), the image is accessible publicly (not behind authentication), and the image file is under 5MB. Facebook requires images to be at least 200x200 pixels.

Twitter preview shows "summary" instead of large image

Make sure you have the tag <meta name="twitter:card" content="summary_large_image" /> in your page head. The default Twitter card type is "summary" (small image). Also ensure your og:image or twitter:image is at least 300x157 pixels for the large image format to display.

Parse HTML mode does not detect my tags

The parser looks for standard meta tag formats. Make sure your tags use proper syntax: <meta property="og:title" content="..." /> or <meta name="twitter:card" content="..." />. Tags with non-standard attribute order or single quotes may not be detected. Also ensure you are pasting the complete <head> section, not just individual tags.

Related Guides

In-depth articles covering the concepts behind Open Graph Preview.

Advertisement

Related Tools