Quick wins for a faster PC:
Repair Windows errors before they cause bigger problemsFix Now →Scan for outdated or missing drivers - takes under a minuteDriver Scan →To check an Open Graph image, inspect the page’s served HTML for <meta property="og:image" content="…">, open that image URL to confirm it loads, then compare the result with the target platform’s parser or preview. The tag tells you what the page declares; it does not guarantee that every social platform can fetch the image or will show it immediately.
What an Open Graph image check tells you
An Open Graph image is the image URL a page declares for sharing through Open Graph metadata. The key tag is og:image, usually placed in the document’s <head>. The protocol’s basic properties are og:title, og:type, og:image and og:url. Checking the tag answers what the HTML says; checking the image URL answers whether that image can be retrieved; checking a platform parser helps show what that platform has read.
Those are separate checks. A correct tag can still point to an inaccessible image, and a correct current page can appear with an old preview if a platform is using cached scrape data. A generic checker can also fetch through a different route than a social platform’s crawler. Use the checks below to isolate which part is failing.
1. Inspect the page’s actual Open Graph tags
View the source delivered for the page
- Open the exact page URL you intend people to share.
- Use your browser’s page-source command (often available by right-clicking the page and choosing View page source) or fetch the URL with a command-line client.
- Search the source for
og:image. Check that it appears in the page’s<head>and note the complete value in itscontentattribute. - Also look for
og:title,og:typeandog:url. These are the protocol’s basic properties, alongsideog:image.
A typical declaration looks like this:
<meta property="og:title" content="A page title">
<meta property="og:type" content="website">
<meta property="og:image" content="https://example.com/images/share-card.jpg">
<meta property="og:url" content="https://example.com/article">The sample domain and values above illustrate the markup only. For your own check, use the URL and image actually served by your site. If the tag is absent, misspelled, or points to an unintended image, the page is not declaring the image you expected in the source you inspected.
Distinguish delivered HTML from the browser’s live DOM
A browser’s developer tools show a live document that scripts may have modified after the initial response. That can be useful for seeing what a visitor’s browser eventually renders, but it is not automatically the same markup a crawler receives or parses. Compare the page source with the live DOM when they differ. If the tag only appears after client-side JavaScript runs, verify what the target platform’s parser reads instead of assuming its crawler will see the browser’s final DOM.
For a quick command-line inspection, save or print the HTML response and search it for og:image. For example, on a system with curl and grep installed:
curl -L -sS "https://example.com/article" | grep -i "og:image"Replace the example URL with the public page URL you are checking. This is a text search, not a full HTML parser: it may miss markup split across lines or show several declarations without explaining how a crawler interprets them. Use it as a quick clue, then inspect the surrounding source or a parser’s output.
2. Check which image URL the metadata describes
Copy the full content value from the intended og:image tag and open that URL directly. Confirm that it resolves to the image you meant to share, rather than an old file, a placeholder, or a page that redirects somewhere unexpected. A value can be syntactically present and still be wrong for the page.
Recommended Free Tools
When present, inspect the related image properties too:
og:image:typeidentifies the image’s media type.og:image:widthandog:image:heightdeclare dimensions.og:image:secure_urlprovides a secure URL for the image.og:image:altdescribes what is in the image; the Open Graph protocol distinguishes this description from a caption.
These are additional metadata, not substitutes for confirming the root og:image value and the actual image file. If a declared alternate or structured value conflicts with the file or the root tag, inspect the complete tag sequence and what the target parser reports. The protocol defines the properties, but a check should not assume every platform handles every optional value identically.
3. Check for duplicate image declarations and ordering
Some pages declare more than one og:image. The Open Graph protocol says that when values conflict, the first tag from top to bottom takes precedence. Read the tags in document order, not just the one returned by a search that happens to look most relevant. If you intend one image, remove unintended duplicates where possible; if you intend several, confirm that the first is the preferred choice.
Keep each image’s structured properties after its corresponding root og:image declaration. That makes the association easier to inspect and follows the protocol’s ordering guidance. After changing the markup, fetch the page source again to confirm the served order has changed, rather than relying only on the CMS editor or a browser preview.
The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →4. Compare your markup with a crawler’s parsed result
A parser or debugger can tell you what a particular fetcher extracted, which is a different question from what your source appears to contain. The Open Graph protocol site identifies Facebook Object Debugger as Facebook’s official parser and debugger. Use the relevant platform’s own debugging interface when the problem is a preview on that platform; it is more directly useful for comparing the platform’s interpretation than a generic visual preview.
A third-party Open Graph checker can be useful to list tags and show a preview in one place. OG Preview describes its fetch as using an external third-party proxy. That means a failure or success in its preview is evidence about that checker’s fetch path, not proof that every platform crawler can or cannot retrieve the same page and image. Compare its parsed metadata with the source and, where available, the target platform’s own parser.
| Check | What it can establish | What it cannot establish by itself |
|---|---|---|
| Page source | The metadata present in the HTML response you inspected, including the declared URL and tag order. | How a specific platform crawler parses or caches the page. |
| Target platform parser/debugger | What that platform’s tool reports for its fetch and parse. | How another platform will behave. |
| Third-party preview checker | Tags and a preview as retrieved by that checker’s fetch path. | That its proxy reaches the same page and image as every social crawler. |
OG Preview’s tool and its disclosure are at OG Preview. Its proxy detail is why generic preview results should be treated as a diagnostic, not as a universal platform verdict.
5. Diagnose an absent, incorrect or stale preview
No image is declared
If the served source has no og:image, add the tag through the system that controls your page metadata, then confirm it appears in the resulting HTML. A CMS setting or SEO plugin may be where you edit it, but the source response is the way to verify what visitors and fetchers receive. Do not stop at saving a setting if the page output remains unchanged.
Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchWindows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallThe tag points to the wrong image
Correct the metadata value, check for duplicates that precede it, and reload the public page source. Then open the new image URL. This separates an editing problem from an asset-delivery problem and catches cases where the page still serves an older declaration.
The image URL does not load for a fetcher
Open the URL directly and inspect what it returns. Then compare the platform parser’s result with a generic checker if available. A crawler may not have the same access path as your browser or a third-party proxy, so a successful browser load alone does not establish that every crawler can retrieve it. Ensure the image is reachable at the declared URL and inspect platform-specific parser output when it is not.
The preview still shows an old image
First establish that the current source and image are correct. If they are, the discrepancy may be cached scrape data rather than a current tag error. Caching and refresh behavior vary by platform; there is no universal refresh procedure established by the Open Graph protocol. Use that platform’s own debugging or validation interface to inspect its current parsed result and follow its available refresh behavior, if any.
For a practical troubleshooting sequence, the OG Preview debugging guide recommends checking source markup, crawler access and cache state alongside platform-specific validators. Treat the exact refresh steps as platform-specific, not as a one-size-fits-all fix.
Or skip the browser setup
If you also need a clean visual capture of the page to inspect its rendered appearance, ScreenshotNeo can return a screenshot or PDF from one GET request. It does not replace checking og:image or a social platform’s parser: a screenshot shows rendered content, not what metadata a crawler parsed. Cookie banners, popups and chat widgets are removed before the shot; bot checks, blank pages and failed loads are never billed. An MCP server lets AI agents take screenshots, and 1,000 screenshots a month are free with no card; paid plans start at $5 for 3,000.
Example cURL request (replace YOUR_API_KEY with your key and the target URL with the page you want to capture). See the ScreenshotNeo API documentation for options:
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://example.com/article -o shot.webpSign up for 1,000 free screenshots a month with no card.
Quick troubleshooting checklist
- Source has no tag: add or correct the page’s Open Graph metadata, then inspect the response again.
- Source has several image tags: check top-to-bottom order; the first takes precedence in a conflict under the protocol.
- Image opens for you but not the parser: compare the target platform’s debugger and a third-party checker without treating either fetch path as universal.
- Parser reports the intended image but the share looks old: investigate that platform’s cached scrape and its own available debugging or refresh interface.
- Browser DOM and source disagree: check whether JavaScript added or changed the tag after the initial HTML response.
The protocol reference is The Open Graph protocol. It is the primary reference for the basic fields, optional image metadata and tag ordering described above.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
