og:image is an Open Graph metadata property that points to an image representing a web page when it is shared. It is not an image file format, and Open Graph does not require one universal image size. For a practical starting point, many sharing guides recommend a 1200 × 630-pixel image, but treat that as a cross-platform design recommendation—not a protocol rule—and check the current requirements of the platform where the link will appear.
What the Open Graph image format actually is
“Open Graph image format” is often used to mean the metadata a page supplies for its share image. The key property is og:image. Its value is a URL, usually an absolute HTTPS URL, pointing to an image that represents the page. When a service builds a link preview, it can use that metadata to identify an image for the preview.
The property does not encode or contain the image. The image itself remains a separate file, such as a JPEG, PNG, or WebP. The Open Graph protocol defines metadata properties for identifying the image and describing it; it does not prescribe a single image encoding or a universal width and height.
Keep three decisions separate: the image file and its visual design, the image URL and metadata in the page’s HTML, and the way a particular sharing service chooses to display the image. A correct tag makes the image available as metadata; it cannot guarantee that every service will show it in the same way.
Add `og:image` to the document head
Put the metadata in the page’s <head>. Use a complete URL that a service fetching the page can retrieve, rather than a path that only makes sense relative to a browser route. Add descriptive alt text as well:
<head>
<meta property="og:image" content="https://example.com/images/article-share.jpg">
<meta property="og:image:alt" content="A red bicycle leaning against a brick wall">
</head>The example URL and description are illustrative; replace them with the actual image URL and an accurate description of your image. The Open Graph protocol recommends specifying og:image:alt when a page specifies og:image. Alt text should say what is in the image, not act as a caption, slogan, or list of keywords.
For a more fully described image, add the structured properties that apply:
<meta property="og:image" content="https://example.com/images/article-share.jpg">
<meta property="og:image:secure_url" content="https://example.com/images/article-share.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="A red bicycle leaning against a brick wall">og:image:secure_urlprovides an alternate image URL for a page that requires HTTPS. If the main URL is already HTTPS, use a suitable secure URL rather than supplying a different or insecure asset.og:image:typedescribes the image’s MIME type, such asimage/jpeg. It should match the actual file.og:image:widthandog:image:heightare dimensions in pixels. Enter the dimensions of the image file you are serving, not merely the dimensions you intended to create.og:image:altdescribes the content of the image. It is not a replacement for the image URL or a caption displayed on the page.
Supply optional values only when they are accurate. Incorrect dimensions or a MIME type that does not match the file can be more confusing to a parser than omitting that information.
Do these 3 things before closing this tab:
1Fix the driver behind crashes, sound loss and screen glitches2Repair Windows errors before they cause bigger problems3Scan for outdated or missing drivers - takes under a minuteIs 1200 × 630 the correct OG image size?
It is a useful starting point, not an Open Graph requirement. The protocol defines image metadata fields, including pixel width and height, but does not establish one mandatory size. OpenGraphImage’s third-party sizing guide recommends 1200 × 630 pixels as a broadly compatible sharing-image size. That recommendation is practical guidance, not a guarantee that every platform accepts, crops, or displays the image identically.
Design for the service and placement you care about. A preview may crop or resize an image, so keep essential text and the subject away from edges where cropping would make them hard to read. Check platform-specific documentation when exact rendering compatibility, file size limits, or image dimensions matter; those requirements can differ and change.
- Choose an image that represents the specific page, not just the site in general.
- Check that the important content remains understandable if the preview is cropped or displayed smaller.
- Confirm the actual pixel dimensions and file type of the asset you publish.
- Use the target platform’s current guidance for its own limits and presentation.
How to provide more than one image
Multiple og:image values are allowed. If a page supplies several candidates, put the preferred image first: when values conflict, the first image tag is preferred. This makes ordering meaningful, so do not assume every consumer will choose a later image that you consider better.
Keep each image’s structured properties immediately after its root og:image tag, before declaring the next image. For example:
Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minuteWindows 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 reinstall<meta property="og:image" content="https://example.com/images/article-wide.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="A cyclist riding along a coastal road">
<meta property="og:image" content="https://example.com/images/article-square.jpg">
<meta property="og:image:type" content="image/jpeg">
<meta property="og:image:width" content="800">
<meta property="og:image:height" content="800">
<meta property="og:image:alt" content="A cyclist beside a coastal road">Here the wide image is first and therefore preferred. The next root image declaration begins a separate image entry. Keep the dimensions and alt text paired with the image they describe; placing all image tags first and all supporting properties afterward can make that relationship unclear to parsers.
Choose and publish an image that works as a preview
Start with the page’s subject
A useful share image helps a person understand what the linked page is about. Select an asset that reflects the page itself, and check that its focal point and any embedded wording remain legible at the sizes where people are likely to see a preview. A site logo alone may identify the publisher but may not explain the shared article.
Check the file and its public URL
Make sure the metadata points to the final image, that the URL is correct, and that the file is available to a service fetching the page. Use HTTPS where appropriate, and ensure any declared MIME type and pixel dimensions correspond to the served file. If you replace an asset, update metadata that still points to its old location.
Inspect the page and the preview separately
First inspect the HTML actually delivered for the page and confirm that the metadata is present in the document head. Then inspect how the intended sharing service renders the link, using that service’s available preview or debugging workflow. Those checks answer different questions: the page source shows what metadata is published; a preview shows how a particular consumer interpreted it. A screenshot of your page can help inspect the page’s visible content, but it is not a substitute for checking the platform-generated link preview.
Best Value
Why is my Open Graph image not showing?
Check the following in order. These are practical debugging checks, not claims that all sharing services handle every failure identically.
- Inspect the rendered head. Confirm the live page includes a correctly spelled
og:imageproperty and a non-emptycontentURL. If your site generates pages dynamically, inspect the delivered HTML rather than relying only on what a template is meant to output. - Open the image URL directly. Verify it resolves to the intended image and can be fetched without requiring a logged-in browser session. Correct a typo, stale path, or inaccessible asset.
- Check the image description fields. Ensure any declared type, width, and height match the actual file, and keep structured properties adjacent to their image tag.
- Check image order. If several image tags exist, the first is preferred when values conflict. Move the intended primary image ahead of alternatives.
- Check the target service’s current rules. Do not assume the Open Graph protocol’s metadata fields define that service’s accepted dimensions, file limits, or crop.
- Recheck the preview after publishing changes. A service may not display a changed page immediately. Use its own current preview/debugging tools to determine whether it is still showing an earlier result.
If the image appears in the page source but not in a share preview, the issue may lie in the asset’s accessibility, the service’s interpretation, or its preview behavior rather than in the fact that the tag exists. Diagnose the fetched page, image URL, and platform preview as separate steps instead of changing the image dimensions at random.
Or skip the browser setup
If you want a screenshot of the published page while checking its visible content, ScreenshotNeo can capture a URL in one API request. It captures the page itself, not a social platform’s generated share card. ScreenshotNeo is a website screenshot API and MCP server for developers; see the ScreenshotNeo site and API documentation for setup and available options.
Quick Recap
cURL:
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://example.com -o shot.webpPython:
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)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}`);Replace the example URL and API key with your page and key. ScreenshotNeo removes cookie banners, newsletter popups, and chat widgets before the shot; those steps can be turned off. Bot checks, blank pages, and failed loads are not billed, and the response identifies the page verdict and billing status. Its MCP server lets AI agents take screenshots. The Free plan includes 1,000 screenshots per month with no card; paid plans start at $5 for 3,000 screenshots. Sign up for 1,000 free screenshots a month—no card required.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
A practical checklist before sharing
- The page has an
og:imageURL that resolves to the intended asset. - The image describes the page and remains understandable at preview scale.
- Alt text describes what is in the image, and image type and dimensions are accurate when supplied.
- If several images are declared, the preferred one comes first and each image’s properties follow its own root tag.
- The target platform’s current requirements and actual preview have been checked when precise rendering matters.
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.
