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 find the image a page declares for social sharing, inspect its published HTML head for meta elements whose property is og:image. Read the URL in content, check duplicate tags and their order, then run the URL through the social platform’s own debugger. Source inspection tells you what the page emits; a platform debugger tells you whether that platform can fetch it and whether its cached preview has updated.
What you are checking
Open Graph (OG) metadata describes a web page when it is shared as a link. The protocol defines four basic required properties:
| Property | Purpose | What to verify |
|---|---|---|
og:title |
The title of the shared object | It is present and matches the page you intend to share |
og:type |
The object type | It is present and appropriate for the page |
og:image |
The representative image URL | The URL is the intended image and is emitted in the document head |
og:url |
The canonical URL for the object | It points to the URL you want platforms to associate with the preview |
Image-specific properties can add the secure URL, MIME type, width, height and alternative text. The alternative-text property is og:image:alt. The image URL should normally be absolute, such as https://example.com/images/share-card.jpg, rather than a path that only makes sense relative to the page.
How to find og:image in the page source
- Open the exact published URL. Use the page as it exists on the public site, not an editor preview or an unsaved CMS draft.
- View the source. In a desktop browser, right-click the page and choose View Page Source, or enter
view-source:before the URL. - Search for
og:image. You are looking for markup like<meta property='og:image' content='https://example.com/image.jpg'>. - Read the
contentvalue. Copy the complete URL and open it in a new tab to confirm that it is the intended image. - Check the other required fields. Search for
og:title,og:typeandog:urlas well.
View-source inspection is useful because it shows the HTML delivered for the page. A setting in a CMS does not prove that the setting reached the published markup; the emitted source is the decisive check.
Do these 3 things before closing this tab:
1Repair Windows errors before they cause bigger problems2Fix the driver behind crashes, sound loss and screen glitches3Clear out junk files and repair common Windows errors#1 Best Overall
Use developer tools when the page is generated dynamically
Open browser developer tools with F12 or Ctrl/Cmd+Option+I, then choose the Elements panel. Expand the document’s <head> element and search for og:image. Inspect the live DOM if the page changes after JavaScript runs.
Compare the live DOM with View Page Source when they disagree. Social crawlers commonly consume the HTML response, so a tag inserted only after client-side JavaScript may not be available to every crawler. The comparison tells you whether your framework or CMS is server-rendering the metadata or adding it later.
Check duplicates and ordering
Record every og:image element, from top to bottom. The Open Graph protocol says that when a property appears more than once, the first value is preferred when values conflict. An old image left above a new one can therefore explain why a preview shows the wrong artwork.
Do the same for repeated og:title or og:url values. Remove stale duplicates where possible; otherwise put the intended value first and verify the final source after publishing.
Free tools Windows power users keep installed
One-click scans. No signup required.
Validate the image itself
- Open the exact URL copied from the
contentattribute. - Confirm that it returns the image you expect rather than a generic placeholder, login page or error document.
- Check that the URL is complete and uses the correct host and path. A typo, redirect or environment-specific hostname can make the page look correct to you while a crawler receives something else.
- Review optional properties when you provide them:
og:image:secure_url,og:image:type,og:image:width,og:image:heightandog:image:alt.
Exact image dimensions, supported formats and crawler rules differ by platform and change over time. The Open Graph specification establishes what the properties mean, but it does not give one universal size or format requirement for every social network. Consult the target platform’s current documentation before treating a particular dimension as mandatory.
Run the URL through the platform’s debugger
HTML inspection answers “what does this page declare?” It does not prove that a social network can reach the page, download the image or refresh an already cached preview. Use the target platform’s current official debugger or inspector after checking the source. The Open Graph protocol site identifies Facebook’s Object Debugger as its official parser and debugger; other networks provide their own tools and policies.
- Paste the public page URL into the platform’s debugger.
- Run the inspection or fetch operation.
- Read the parsed title, URL and image, and note any fetch or access error.
- If the tool offers a refresh or re-scrape action, use it after correcting the page.
- Share a new test link only after the debugger reflects the corrected metadata.
A generic tag inspector can present parsed fields conveniently, but it cannot establish platform-specific reachability or cache state. Treat its result as a source check, not as proof that every network will display the same card.
Why the wrong image or no image appears
An older og:image comes first
List all image tags and compare their order. Because the first value wins in a conflict, remove the obsolete tag or move the intended one above it.
Recommended Free Tools
The CMS setting was not emitted
Inspect the published source, not the CMS configuration screen. Check the template, SEO plugin output and the final URL after deployment. CMS guidance can help maintain social metadata, but the rendered page remains the authority.
The crawler cannot fetch the page or image
A tag can be perfectly formed while a platform still cannot retrieve the URL. Use that platform’s debugger and investigate the access error separately. Source inspection alone cannot distinguish a crawler access problem from a stale preview.
The preview is cached
Correcting HTML does not automatically guarantee that an existing preview changes immediately. Re-run the platform’s official inspector and follow its current refresh process. Cache behavior and refresh controls are platform-specific.
The image is present but lacks useful alternative text
Add og:image:alt when you can describe the image. This property supplies alternative text for the Open Graph image; it does not replace the image URL.
Best Value
For a repeatable CMS workflow
For one URL, source inspection and a platform debugger are sufficient. For a site that publishes frequently, configure the social metadata in the CMS or SEO system, then validate the actual output after each template change. A practical release check is:
- Confirm one intended value for each required property.
- Confirm the image URL is absolute and points to the production host.
- Check for duplicate tags introduced by a theme, plugin or component.
- Run a representative URL through the target platform’s debugger.
- Keep a record of the published source when troubleshooting so you can identify when a template change introduced a stale value.
Or skip the browser setup
ScreenshotNeo can capture the rendered page in one request when you need a visual confirmation of what a URL displays. It is a screenshot API and MCP server, not a replacement for reading raw OG tags, so use source inspection for the metadata values and the capture for the visible result.
Before the capture, ScreenshotNeo accepts cookie or consent banners and removes more than 60 known consent platforms, newsletter popups and chat widgets; each cleanup step can be turned off. Only clean shots are billed: bot checks or CAPTCHAs, blank pages, timeouts, failed loads and cache hits cost nothing, and the response identifies the result with X-Page-Verdict and X-Billed headers. Its MCP server provides take_screenshot, get_page_info and capture_pdf tools for Claude, Cursor and other MCP clients.
Use the API documentation at https://screenshotneo.com/docs/. This cURL request captures a page as WebP:
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://example.com -o shot.webpThe same request in Python:
import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://example.com"}, timeout=90)
open("shot.webp", "wb").write(r.content)And in Node.js:
const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://example.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);ScreenshotNeo includes full-page capture with lazy images loaded, CSS-selector element capture, custom CSS and JavaScript, waits for a selector, delay or network idle, custom headers and cookies, dark mode, device presets, retina scale, PDF output, caching with a chosen TTL, signed links and bulk capture. Every feature is on every plan. The Free plan includes 1,000 shots per month with no card; paid plans start at $5 for 3,000 shots. Create a free ScreenshotNeo account to try it.
Troubleshooting checklist
| Symptom | Likely cause | Fix |
|---|---|---|
No og:image in a checker |
The tag is missing from the head or the checker received different HTML | Inspect the published source and verify the CMS/template output |
| Several images are listed | An old tag or plugin generated a duplicate | Use the first-value rule, then remove stale duplicates |
| Source is correct, preview is wrong | Platform cache or a crawler fetch problem | Use the target platform’s debugger and its current refresh procedure |
| Image URL opens for you but not the platform | Platform-specific access failure | Read the debugger’s fetch error and check access to both page and image |
| Live DOM has tags but source does not | Metadata is inserted client-side | Configure server-rendered or otherwise crawler-visible metadata, then recheck source |
| Image appears visually but is not the declared image | The page’s visible hero image and OG image are separate | Compare the rendered page with the explicit og:image URL; change the tag if the share image should match |
Performance, reliability and cost considerations
For a single page, reading source is the fastest and cheapest method because it makes no external request beyond loading the page. A platform debugger adds the evidence you need about that platform’s crawler and cache. A screenshot service adds a rendered visual check and is useful when you need repeatable captures across many URLs, but it should not be treated as a metadata parser.
When automating checks, save the URL, the complete set of OG properties, the order of repeated values and the debugger result separately. That separation prevents a successful HTML parse from being mistaken for proof that a social platform accepted the preview.
Quick Recap
Final verification sequence
- Inspect the published document head.
- Confirm
og:title,og:type,og:imageandog:url. - Check duplicate properties and first-value ordering.
- Open and verify the declared image URL.
- Run the page through the target platform’s official debugger.
- Refresh or re-scrape using that platform’s current process if the preview is stale.
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.
