← Blog

Check Meta Image (og:image): How to Fix Social Preview Problems

2026-11-14 · IndexNowFast Team
Check Meta Image (og:image): How to Fix Social Preview Problems

Quick Answer

To check meta image settings on a webpage, inspect its published HTML for the og:image property, copy the image URL, and open that URL independently. Confirm that the image loads, has the expected file format and dimensions, and is publicly accessible. Then test the webpage using the diagnostic tool for the social platform where the preview appears incorrectly.

These three checks help identify whether the problem is metadata, the image file, or outdated platform caching.

This guide focuses on Open Graph images used in social-sharing previews, rather than EXIF or IPTC metadata stored inside image files.

The basic HTML declaration looks like this:

``html <meta property="og:image" content="https://example.com/images/article-cover.jpg"> ``

The og:image property tells compatible platforms which image represents a webpage when someone shares its URL. However, adding this tag does not automatically guarantee that every platform can retrieve or display the image.

Key Takeaways

  • The og:image property identifies the preferred image for a shared webpage.
  • Inspect the published HTML rather than relying exclusively on your CMS image settings.
  • Open the declared image URL separately to verify that the actual resource works.
  • Compare declared dimensions and file types with the image itself.
  • Social platforms can retain outdated preview information even after website changes.
  • Google's search thumbnails and social-sharing previews are separate image-selection processes.

What Does the Meta Image (og:image) Tag Do?

The meta image tag is an Open Graph property that identifies an image associated with a webpage. Open Graph is a metadata protocol that helps websites communicate information about their content to social platforms and other compatible services.

For example, when someone shares a blog post, the receiving platform may use its Open Graph metadata to generate a preview containing a title, description, and image.

The official Open Graph protocol specification identifies og:image as one of the four basic required properties for an Open Graph object. It provides the image URL representing the shared content.

A typical implementation appears inside the document's HTML head:

``html <head> <title>Example Article</title> <meta property="og:title" content="How to Improve Website Performance"> <meta property="og:description" content="Practical ways to improve website speed."> <meta property="og:image" content="https://example.com/images/performance-guide.jpg"> <meta property="og:url" content="https://example.com/performance-guide/"> </head> ``

There are several related elements worth distinguishing:

  • og:image identifies the image associated with the shared content.
  • og:url identifies the canonical URL of the Open Graph object.
  • og:title supplies its title.
  • og:description supplies a description.
  • An ordinary HTML alt attribute describes an image element within the webpage; it does not replace og:image:alt in Open Graph metadata.

For a deeper explanation of URL identity and canonical relationships, see Meta Property og:url: What It Means, HTML Examples, and Fixes.

The important distinction is that a website image and a social-sharing image are not necessarily the same. A featured image may appear correctly inside an article while the generated Open Graph metadata points to a different file or contains no image URL at all.

How to Check a Webpage's Meta Image

You can check a meta image manually without purchasing an SEO subscription. The following process separates the webpage's metadata from the image resource and the platform's final preview.

Step 1: Open the Published Webpage

Start with the exact webpage URL that people share.

For example:

``text https://example.com/blog/website-performance-guide/ ``

Avoid using an unpublished CMS preview or an unrelated homepage. The published URL matters because the HTML generated for a preview may differ from the version actually delivered to visitors and social crawlers.

If the page redirects, make sure you understand which final URL is being served.

Step 2: Inspect the Published HTML Source

Open the webpage in a desktop browser such as Chrome.

Right-click the page and select View Page Source. Alternatively, use the browser's source-view shortcut where supported.

Once the source opens:

  1. Press Ctrl + F on Windows or Linux, or Command + F on macOS.
  2. Search for og:image.
  3. Examine every matching declaration.
  4. Locate the content attribute containing the image URL.

A valid-looking result might be:

``html <meta property="og:image" content="https://example.com/images/blog-cover.jpg"> ``

Copy the complete URL, including its HTTPS scheme and filename.

Do not assume that finding one matching property means the page is correctly configured. Check for missing values, empty attributes, duplicate declarations, and conflicting image URLs.

Also remember that some websites generate metadata using JavaScript. If the initial source does not contain the expected property, inspect the rendered DOM and compare it with what the intended social crawler can retrieve. A browser displaying a generated tag does not necessarily establish that every crawler receives the same result.

Step 3: Check the Image URL Independently

Copy the og:image URL and paste it into a new browser tab.

The image should open as an actual image rather than an HTML error page, login screen, or unrelated redirect destination.

Check the following:

  • Accessibility: Can an unauthenticated visitor access the image?
  • Response: Does the image request return a successful response, normally HTTP 200?
  • File type: Is the returned resource actually an image, such as JPEG, PNG, or WebP?
  • URL validity: Does the URL resolve correctly without malformed characters or broken paths?
  • Access restrictions: Is the resource blocked by permissions, firewall rules, hotlink protection, or crawler restrictions?

A successful browser request is useful evidence, but it does not prove that every social platform's crawler can access the same resource. Different crawlers may encounter different access policies, network restrictions, or response behavior.

Step 4: Inspect the Actual Image Dimensions

An image URL can work perfectly while still producing a poor social-sharing preview.

Open the downloaded or displayed image in an image editor, image viewer, or file-properties interface. Check its actual width and height rather than relying only on the dimensions declared in the HTML.

For example, an image might have these properties:

AttributeExample value
Width1200 pixels
Height630 pixels
Aspect ratioApproximately 1.90:1
FormatJPEG
AccessibilityPublicly accessible

These values illustrate an image inspection; they are not a universal requirement for every social platform.

Look for three practical characteristics:

Resolution: The image should have sufficient pixel dimensions for its intended display. A very small image can become blurry when expanded into a large preview.

Aspect ratio: Extremely wide or tall images may be cropped or displayed differently by individual platforms.

Visual relevance: The image should represent the actual webpage. A generic company logo may be less useful than a relevant article cover or product image.

Do not confuse the image's physical dimensions with the dimensions declared in its metadata. The two should agree when structured dimension properties are supplied.

Step 5: Test the Actual Social-Sharing Preview

After verifying the HTML and image resource, test the complete webpage using the diagnostic tool for the platform where the problem occurs.

This step matters because a technically correct image URL does not establish that a social platform has fetched and selected that image.

Compare the diagnostic result with the published HTML:

  • Is the expected image URL being discovered?
  • Does the platform identify a different image?
  • Are there warnings about inaccessible resources?
  • Does the displayed preview appear outdated?
  • Does the image render correctly but appear cropped?

A dedicated Open Graph checker can make the inspection faster. Examples include:

These are third-party tools, not official platform diagnostics. Their reported information should be treated as an additional inspection aid rather than proof that every social network will display an identical preview.

Which og:image Properties Should You Check?

The main og:image property identifies the image URL. The Open Graph protocol also defines additional image properties that provide useful information about the resource.

PropertyWhat it tells youWhat to verify
og:imageMain image URLCorrect, complete image address
og:image:urlImage URL alternativeConsistency with the primary image reference
og:image:secure_urlSecure image URLValid HTTPS destination where supplied
og:image:typeDeclared image MIME typeAgreement with the actual file format
og:image:widthDeclared image widthAgreement with actual pixel width
og:image:heightDeclared image heightAgreement with actual pixel height
og:image:altDescriptive image alternative textAccurate, useful description

An expanded example looks like this:

``html <meta property="og:image" content="https://example.com/images/article-cover.jpg"> <meta property="og:image:secure_url" content="https://example.com/images/article-cover.jpg"> <meta property="og:image:type" content="image/jpeg"> <meta property="og:image:width" content="1200"> <meta property="og:image:height" content="630"> <meta property="og:image:alt" content="Illustration of a website performance dashboard"> ``

The example demonstrates the available metadata fields. It does not mean every optional property must be included on every webpage.

The official Open Graph specification provides the underlying definitions and structured-property rules.

One particularly useful check is comparing og:image:type with the server's actual image response. Declaring a JPEG while serving an incompatible resource creates an inconsistency that should be investigated.

Why Is the Wrong Meta Image Showing?

When a social preview displays the wrong image, changing the featured image repeatedly is rarely the best first response. Identify which layer is failing before making changes.

1. The og:image Tag Is Missing

If the published HTML contains no og:image declaration, the platform cannot retrieve the intended image through that property.

Some platforms may select another image from the webpage, but that behavior should not be treated as a reliable replacement for correct metadata.

What to do: Add the intended Open Graph image through your CMS, theme, or website template. Then inspect the generated published HTML to confirm that the property exists.

2. The Image Content Attribute Is Empty

A page may contain an incomplete declaration:

``html <meta property="og:image" content=""> ``

This usually points to a CMS configuration problem, an unavailable featured image, or a template that generates an empty value.

What to do: Check the page's social-sharing image settings and the template responsible for producing the HTML. Confirm that the published tag contains a complete image URL.

3. The Image URL Is Relative or Incorrect

Consider this declaration:

``html <meta property="og:image" content="/images/article-cover.jpg"> ``

A relative URL depends on the webpage's base address. Although browsers can resolve relative paths in an HTML document, using a complete absolute image URL makes the intended resource explicit for sharing metadata.

A better example is:

``html <meta property="og:image" content="https://example.com/images/article-cover.jpg"> ``

What to do: Correct the URL generated by your CMS or template and confirm that the complete destination loads independently.

4. The Image File Is Inaccessible

The HTML may contain a correct image URL even though the file cannot be retrieved by the intended platform crawler.

Possible causes include:

  • Deleted or renamed image files.
  • Incorrect file permissions.
  • Authentication requirements.
  • Firewall or security restrictions.
  • Hotlink protection.
  • Server errors or broken redirects.

What to do: Check the image's response, server configuration, and access restrictions. Make sure the intended public image can be retrieved without requiring a login or special browser session.

5. Multiple og:image Tags Conflict

A page can contain several image declarations. The Open Graph protocol supports multiple image properties, but their order and associated metadata matter.

Problems can occur when a CMS plugin, theme, and custom code each generate their own tags.

For example:

``html <meta property="og:image" content="https://example.com/images/old-cover.jpg"> <meta property="og:image" content="https://example.com/images/new-cover.jpg"> ``

A platform may interpret multiple declarations according to its own processing behavior.

What to do: Inspect all generated declarations, identify which image should be prioritized, and remove accidental conflicts. Do not assume that the last declaration will always win.

6. The Preview Uses an Old Cached Image

Sometimes the website has already been updated, but the social platform continues showing the previous image.

This happens because platforms may store previously fetched information to avoid retrieving the same webpage every time someone shares it.

What to do: Use the platform's URL inspection or preview-refresh mechanism where available. Confirm that the platform retrieves the current metadata rather than relying on an older cached result.

7. The Image Is Cropped or Selected Differently

A social platform may display only part of the intended image because its preview layout differs from the original image dimensions. A platform may also select another image based on its own processing rules.

What to do: Check the platform's actual preview, review the image composition, and consult its current image specifications. Keep important visual information away from extreme edges when preparing a cover intended for multiple display formats.

How to Refresh an Outdated Social Preview

Correcting the og:image tag is only part of the solution. You may also need to ask the intended social platform to retrieve the webpage again.

Refreshing a LinkedIn Preview

LinkedIn provides a diagnostic feature called Post Inspector.

It allows publishers to inspect how a URL is interpreted and refresh the information used for link previews.

A practical workflow is:

  1. Open LinkedIn Post Inspector.
  2. Enter the published webpage URL.
  3. Inspect the information retrieved for that URL.
  4. Compare the displayed image with the current og:image declaration.
  5. Refresh the URL information where supported.
  6. Check the preview again when creating a new post.

An important limitation: LinkedIn's documentation explains that refreshed information affects new posts. Existing posts retain their original preview.

Therefore, refreshing a URL should not be understood as changing every previously published LinkedIn post.

Refreshing a Facebook Preview

Facebook provides a Sharing Debugger for inspecting how shared URLs are interpreted.

The workflow described in Yoast's Facebook sharing troubleshooting documentation involves inspecting a URL, requesting another scrape, and reviewing the resulting preview and metadata warnings.

The debugger can help distinguish an outdated cached preview from a problem with the webpage's current metadata.

However, the current interface and access requirements have not been independently tested for this guide. Check the available Facebook diagnostic interface before relying on specific navigation instructions.

Also remember that requesting a new scrape does not repair an inaccessible image file or automatically correct an invalid HTML declaration. Fix the underlying issue first, then request another retrieval.

Does og:image Control the Image Google Shows in Search?

Not completely.

Google documents og:image as one way website publishers can indicate a preferred image, but Google selects images automatically and may consider other information.

According to Google's Image SEO documentation, publishers can influence preferred image selection through structured image properties or Open Graph image metadata.

Google also recommends choosing relevant, representative images, avoiding extreme aspect ratios, and providing high-resolution images where possible. However, this does not guarantee that Google will display the exact image specified in og:image.

There are three separate image situations to understand:

Image situationWhat determines the image
Website article imageHTML content, theme, CMS, and page layout
Social-sharing previewOpen Graph metadata and platform-specific processing
Google search thumbnailGoogle's automated image-selection systems and available page signals

Google also provides a separate image-preview control through the max-image-preview robots directive.

The Google robots meta-tag documentation defines three values:

  • none: No image preview.
  • standard: A default image-preview size.
  • large: A larger image preview where applicable.

This directive controls the maximum image-preview size in applicable Google search experiences. It does not identify the social-sharing image URL and cannot replace og:image.

If your concern is whether a webpage appears in Google's index, that is another technical check. Index status and social-image metadata are different questions. You can use the IndexNowFast Google Index Checker to investigate the index status of public URLs.

A non-indexed result does not, by itself, explain an incorrect social preview.

A Practical Meta Image Troubleshooting Checklist

The most efficient way to diagnose a meta image problem is to work through three independent layers.

Layer 1: Page Metadata

Inspect the actual published HTML.

  • Find the og:image property.
  • Record the exact image URL.
  • Check whether its content value is empty.
  • Look for duplicate or conflicting declarations.
  • Confirm that the image address is complete and valid.
  • Review relevant structured image properties.

The objective is to establish what the webpage actually declares, rather than what the CMS claims it should declare.

Layer 2: Image Resource

Open the declared URL separately.

  • Confirm that the image is publicly accessible.
  • Inspect the HTTP response.
  • Verify the actual image MIME type.
  • Measure the real image dimensions.
  • Compare the actual dimensions with declared values.
  • Check image quality, composition, and relevance.

The objective is to establish whether the declared resource actually exists and can be used.

Layer 3: Platform Preview

Test the webpage using the diagnostic mechanism for the intended social platform.

  • Compare the platform's retrieved image with the declared URL.
  • Inspect any metadata or access warnings.
  • Determine whether the preview is outdated.
  • Refresh cached information where supported.
  • Check a newly created post rather than assuming an old post will change.

The objective is to establish whether the platform can retrieve and display the current information.

Meta Image Diagnostic Decision Matrix

Use this table to identify the likely problem and choose the next action.

What you observeLikely problemRecommended action
No og:image foundMissing metadataAdd the intended property
Empty image contentCMS or template configurationCorrect the generated HTML
Relative or malformed URLURL generation problemPublish a valid absolute URL
Image URL does not loadResource or access problemRepair the file or crawler access
Actual dimensions differ from declared dimensionsMetadata inconsistencyCorrect the structured properties
Image loads but preview is incorrectPlatform fetching or image selectionInspect the platform's diagnostic result
Correct source but old previewCached social informationRefresh the platform preview
Google displays a different imageIndependent image selectionInvestigate Google's image-selection signals

This framework is a practical diagnostic sequence based on the Open Graph specification and documented platform behavior, not a claim of results from an independent software experiment.

Its main advantage is that it prevents unnecessary changes. If the metadata is correct but the file is unavailable, changing the CMS featured image may not solve anything. If both are correct but the preview is outdated, the next step is to investigate caching rather than repeatedly editing the webpage.

Frequently Asked Questions

How do I find the og:image tag in HTML?

Open the published webpage, select View Page Source, and search for og:image. Find the declaration containing the content attribute. Copy that URL and open it separately to verify the image resource.

Can I check a meta image without a paid SEO tool?

Yes. Your browser's View Page Source feature can reveal the metadata, and opening the image URL allows a basic accessibility check. You can also use available social-platform diagnostic tools and third-party Open Graph checkers.

Why does my og:image URL work but the preview still look wrong?

The platform may be using cached information, selecting another available image, encountering crawler-specific access restrictions, or applying its own preview layout. Compare the current HTML with the platform's diagnostic result before changing the image.

Can a webpage have more than one og:image property?

Yes. The Open Graph protocol supports multiple image declarations. However, their order and associated properties can affect how they are interpreted. Inspect all declarations and remove accidental conflicts rather than assuming every platform will choose the same image.

How do I update an old Facebook or LinkedIn image preview?

Use the relevant platform's URL diagnostic or preview-refresh mechanism after correcting the website's metadata. LinkedIn Post Inspector can refresh information for new posts, but existing LinkedIn posts retain their original previews. Facebook's Sharing Debugger can help inspect and request another scrape of a URL.

Does changing the featured image automatically change og:image?

Not necessarily. Many CMS platforms generate Open Graph metadata from the featured image, but the behavior depends on the theme, plugin, and page configuration. Inspect the published HTML after changing the featured image to confirm that the og:image value has actually changed.

Is og:image the same as the image Google displays in search?

No. og:image identifies an image associated with a shared webpage and can influence Google's preferred image selection. Google makes its own automated selection and does not guarantee that the declared Open Graph image will appear in search results.

Final Thoughts: Check the Metadata, the Image, and the Preview Separately

Checking a meta image is not simply a matter of finding an og:image tag. A complete verification requires confirming that the published HTML declares the intended image, that the image URL returns the correct publicly accessible resource, and that the intended social platform retrieves and displays the expected preview.

These checks answer three different questions. The metadata check identifies what the website declares. The resource check establishes whether the image actually works. The platform check reveals whether the social-sharing service is using the current information or displaying an older cached result.

If something goes wrong, identify the failing layer before changing the website again. This makes troubleshooting more accurate, reduces unnecessary edits, and helps ensure that the image shared with readers represents the content they are about to visit.