Open Graph Image Checker: Inspect and Fix Link Preview Images

An Open Graph image checker fetches a webpage and reads metadata such as og:image, which declares the image associated with that page. Use one to confirm that the exact URL you plan to share exposes the intended image and related title and description. A checker’s report describes what it fetched; a simulated preview does not guarantee what every social platform currently displays or prove that the platform has refreshed its cached scrape.

To diagnose a wrong preview, inspect the exact shared URL, verify the fetched og:image, then check that image is publicly retrievable and suitable for the platform. If the metadata looks right but a real share remains stale or different, investigate that platform’s fetch and cache behavior.

1. What an Open Graph image checker checks

The Open Graph Protocol defines core properties including og:title, og:type, og:image, and og:url. The image property identifies the image associated with the page or object. A checker can fetch a page and report the tags it sees, helping you spot missing, malformed, or unexpected values.

A checker reads metadata from the fetched page and may render a preview from those values.

For a practical review, start with the canonical URL that people will share and confirm:

og:title is the title you intend to appear.
og:description describes the page accurately.
og:url identifies the intended page URL.
og:image points to the intended image, not a fallback or unrelated asset.

Some checker tools also fetch the image and report dimensions, whether it loads, HTTPS status, or alt text. Those are useful optional checks, but they are not capabilities every checker provides or universal protocol requirements. A preview drawn from the returned tags is a simulation based on those tags. It is different from a platform-native debugger that asks a social network to fetch the page and shows its own current scrape.

2. Inspect the page manually

For a page you control, checking the HTML response is often the fastest first step. The Open Graph fields should be in the document head and available in the response that a crawler fetches.

<!doctype html>
<html lang="en">
<head>
  <meta property="og:title" content="Product guide">
  <meta property="og:type" content="website">
  <meta property="og:url" content="https://example.com/guide">
  <meta property="og:image" content="https://example.com/images/guide-share.jpg">
  <meta property="og:description" content="A short description of the guide.">
</head>
<body>...</body>
</html>

Replace example values with your own. The protocol supports structured image properties such as image MIME type, width, height, an HTTPS alternative URL, and descriptive alt text. These can make the metadata more informative; confirm the actual image resource agrees with the declared values.

<meta property="og:image" content="https://example.com/images/guide-share.jpg">
<meta property="og:image:secure_url" content="https://example.com/images/guide-share.jpg">
<meta property="og:image:type" content="image/jpeg">
<meta property="og:image:width" content="1200">
<meta property="og:image:height" content="627">
<meta property="og:image:alt" content="A product guide cover with a dashboard illustration">

See the protocol reference for the property definitions. If your page uses a content management system or server rendering, inspect the delivered page source, not only the editor fields: templates, plugins, or route-specific data can change what is emitted.

3. A repeatable checker workflow

Choose the share URL. Use the precise public URL users paste, including its canonical host, path, and relevant redirect behavior.
Fetch the page in a checker. Record the raw metadata values the checker found, especially title, description, URL, and image.
Open the image URL. Confirm it resolves publicly without a login, expired signature, or access restriction. Verify the returned asset is the image you expect.
Review dimensions and format. Compare them with the destination platform’s requirements. If the checker does not inspect image bytes, use an image viewer or your own HTTP tooling.
Compare preview and tags. If the checker draws a card, treat it as a useful interpretation of the fetched metadata, not proof of the platform’s live cache.
Check the platform’s own debugger or sharing flow. When the live result differs, ask that platform to fetch or refresh the URL using its supported tools.

For example, LinkedIn’s official sharing guidance lists og:title, og:image, og:description, and og:url; for its sharing module it specifies minimum image dimensions of 1200 by 627 pixels. That is LinkedIn-specific guidance, not a universal requirement for all networks. Consult LinkedIn’s website sharing requirements when preparing a LinkedIn share.

4. Why a checker and a shared post can differ

A metadata checker and a social network do not necessarily make the same request or show the same state. A checker may fetch the page and construct a mock preview from what it found. A network’s crawler can have its own fetch result and cached scrape. A correct checker result therefore narrows the problem but does not establish that the network fetched the same response or refreshed its stored preview.

A checker’s mock preview and a platform’s current cached scrape are separate results.

When the preview differs, test in this order:

Confirm you checked the same URL, including redirects and canonical host.
Look at the checker’s raw tag values and ensure the image URL is not an old deployment value.
Open the image URL directly and check that it is public and serves the intended file.
Check the platform’s native sharing debugger or troubleshooting guidance for its current scrape.
After changing metadata or replacing an image at the same URL, request a fresh platform scrape if that platform offers the option.

Do not assume a simulated card means every platform has updated. OGForge, for example, describes its preview as a mock based on fetched tags and directs users to platform-native debuggers for cache refreshes; treat that as an example of one checker’s behavior, not a guarantee about all tools.

5. Common image and metadata problems

Symptom	Likely cause	What to do
No image tag appears	The page template does not emit `og:image`, or the checker received a different route or response.	Inspect the exact URL’s delivered head, update the template or route data, then fetch it again.
The wrong image is reported	A fallback, stale CMS value, or duplicate metadata is taking precedence in the fetched document.	Inspect all returned image declarations and remove or correct conflicting output. Verify the final HTML after deployment.
The image URL cannot be opened	The asset may be private, protected, expired, or otherwise unavailable to a public fetch.	Serve the image at a publicly reachable URL and verify it without an authenticated browser session.
Checker card looks right; social post does not	The checker’s fetched preview and the platform’s fetch or cached result differ.	Use the platform’s own debugger or sharing troubleshooting workflow and check its current scrape.
LinkedIn omits or changes the image	The image may not meet the LinkedIn sharing module’s requirements, or LinkedIn may be unable to retrieve it.	Check its official minimum dimensions (1200 × 627 px) and whether the site or asset location blocks retrieval.
Image dimensions shown by a checker are unexpected	The file at the URL differs from the dimensions recorded in metadata, or the checker does not inspect the actual file.	Verify the image bytes with an image viewer or image-processing tool; update the asset and any declared dimensions.
Changes appear in one place but not another	Different tools may have fetched at different times or may display a stored result.	Compare fetch time and raw tags, then request an updated scrape through the destination platform when available.

6. Choosing a checker for the job

Checker features vary, so choose based on what you need to verify rather than assuming every preview is a full audit. Compare whether a tool:

shows raw fetched metadata, including all relevant Open Graph tags;
fetches the referenced image and checks whether it loads;
reports image dimensions or other asset details;
simulates a particular network’s card appearance;
provides a path to the platform-native debugger for checking its actual scrape.

A tool that only reads tags can answer whether the page declares an image. It cannot establish that the destination network has refreshed its cache. A mock card helps visualize the metadata’s effect, but should not be described as an exact reproduction of every platform’s behavior.

7. Capture the rendered page when metadata is not enough

Metadata tells a crawler which image to associate with a page; it does not show how the live page itself renders. If you are documenting a page, comparing its visible layout, or keeping a visual record while debugging, capture the rendered page as a separate check. A screenshot can reveal an unexpected overlay or blank render, but it does not replace an Open Graph metadata check: inspect both the tags and the visible page for their respective questions.

Or skip the browser setup

For a rendered screenshot, ScreenshotNeo is a website screenshot API and MCP server. Its one-request API returns a screenshot or PDF, and the parameters other screenshot APIs use also work. See the ScreenshotNeo API documentation.

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://example.com/guide -o shot.webp

Python:

import requests

r = requests.get(
    "https://api.screenshotneo.com/v1/shot",
    params={"access_key": "YOUR_API_KEY", "url": "https://example.com/guide"},
    timeout=90,
)
open("shot.webp", "wb").write(r.content)

Node.js:

const q = new URLSearchParams({
  access_key: 'YOUR_API_KEY',
  url: 'https://example.com/guide'
});
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);
if (!res.ok) throw new Error(`Screenshot request failed: ${res.status}`);
await Bun.write('shot.webp', res);

Cookie banners, newsletter popups, and chat widgets are removed before the shot, and each cleanup step can be turned off. Bot checks, blank pages, failed loads, timeouts, and cache hits are never billed; response headers report the page verdict and billing state. Its MCP server gives AI agents tools to take screenshots, get page information, and capture PDFs. The free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000. Sign up for 1,000 free screenshots a month, no card required.

8. Reliability, performance, and cost notes

For metadata debugging, repeatability matters more than a preview’s appearance alone. Record the precise URL checked and the raw values returned so you can compare before and after a page change. If a page is behind authentication or blocks public retrieval, the result may not represent what an unauthenticated crawler can access. Confirm public visibility using the actual image and page URLs.

For LinkedIn, follow the image guidance documented for its sharing module and remember it may be unable to retrieve assets from protected locations. Do not generalize one service’s dimensions or cache behavior to every platform. When using a screenshot service to inspect a rendered page, options such as waiting for a selector or network idle can help with dynamic content; blocking unnecessary resources or using caching can affect speed and freshness. Choose settings to match whether you need a current render or a repeatable record. A cached screenshot is useful for reuse but does not verify that a platform has refreshed its own social preview.

9. FAQ

Not necessarily. A checker can fetch and display metadata independently. Use the relevant network’s own sharing debugger or refresh workflow to investigate its scrape.

Is 1200 × 627 the right image size for every platform?

No universal requirement is established here. LinkedIn specifies 1200 by 627 pixels as its sharing module’s minimum; check each destination’s own guidance.

Is an image preview enough to confirm my tags are correct?

No. Inspect the raw fetched tag values as well as any rendered card. A visual mock can look plausible while concealing a wrong URL or other metadata issue.

Should I use a screenshot to check my Open Graph image?

A screenshot shows the rendered page. Use a metadata checker to inspect Open Graph declarations, and use a screenshot when you also need to inspect the page’s visible rendering.