Open Graph images: sizes, caching and debugging

The Open Graph protocol makes og:image one of four required properties on a page and defines it as an image URL that represents the page. It also defines optional structured properties that describe the image:

• og:image:width and og:image:height, in pixels.
• og:image:type, the image’s MIME type.
• og:image:alt, a description of what is in the image, not a caption. The protocol says a page that sets og:image should set this too.
• og:image:secure_url, an alternate URL for pages that require HTTPS. If your og:image is already an https URL, you don’t need it.

<meta property="og:image" content="https://yoursite.com/og.png">
<meta property="og:image:type" content="image/png">
<meta property="og:image:width" content="1200">
<meta property="og:image:height" content="630">
<meta property="og:image:alt" content="The Acme Invoices dashboard with three unpaid invoices">

You can list several images by repeating the tag. The protocol gives the first one preference, and each structured property applies to the og:image above it. The width and height are worth the two lines: Meta says they let its crawler render the image on the first share instead of downloading it first to measure it (source).

The rest of the head, including twitter:card, is covered in meta tags that matter.

These figures come from each platform’s own pages, read in November 2026. They change, so follow the links before relying on one.

• Facebook (Meta). At least 1200 × 630 pixels for the best display on high-resolution devices, and as close to a 1.91:1 aspect ratio as possible to avoid cropping in Feed. 600 × 315 is the minimum for a link post with a large image; smaller images still display, much smaller. The minimum allowed is 200 × 200, and the file must not exceed 8 MB (Meta’s image guide).
• LinkedIn. A recommended ratio of 1.91:1, a maximum file size of 5 MB, and “minimum image dimensions” of 1200 × 627 pixels. Images less than 401 pixels wide display as a thumbnail (LinkedIn Help).
• X. This guide doesn’t quote X’s dimensions, because they aren’t taken here from X’s own card documentation. Check that before relying on a size. One figure is available second-hand: the Next.js docs say a twitter-image file must not exceed 5 MB, citing X’s card documentation, and that a build fails above that (source).
• Slack. Slack says it looks for Open Graph and Twitter Card metadata and fetches the image those tags point to (unfurling docs, crawler docs). Neither page gives image dimensions.
• Discord. The developer documentation describes the embed object a link preview becomes, but publishes no image size or caching rules for previews built from a page’s tags (source).

One image at 1200 × 630, as a PNG or JPEG well under 5 MB, satisfies everything documented above. It’s 3 pixels taller than LinkedIn’s figure at the same 1.91:1 shape. Layouts that crop to another shape exist, so keep the logo and any text away from the edges.

A card is built by a server-side fetch, with no browser, no cookies and usually no JavaScript. Four things follow from that.

• Use an absolute URL. The protocol defines og:image as a URL and every example in it is absolute. The Next.js metadata reference marks Open Graph and Twitter image URLs “Must be an absolute URL” (source). Write https://yoursite.com/og.png, not /og.png.
• Put the tags in the server’s HTML. The Next.js docs describe facebookexternalhit as a bot that can’t execute JavaScript (source). Tags added in the browser by a single-page app don’t exist for it.
• Put them early, and answer fast. Meta says Open Graph properties must appear within the first 1 MB of the page or they are cut off, and that its crawler has to be able to fetch the content within a few seconds (source). Slack fetches as little of the page as it can, using HTTP Range headers (source).
• Keep the image public. LinkedIn’s explanation for an image that meets its requirements and still doesn’t appear is that the site may be blocking LinkedIn from pulling it, or that the image is in a protected directory (source).

In Next.js, a file named opengraph-image.png in a route folder, or an opengraph-image.tsx that generates one, produces the og:image tag along with its type, width and height. A static opengraph-image over 8 MB fails the build (source).

Platforms don’t fetch your page each time a card is displayed. They keep a copy, and what they key it on decides what you have to do.

Facebook

Meta caches images by the image’s URL. Its instructions for replacing one are to use a new URL for the new image “or the image won’t be updated”, and to leave the old file in place because existing posts still reference it (source). A renamed file or a version in the query string, like og.png?v=2, makes it a new URL. Then run the page through Meta’s Sharing Debugger, which shows the tags the crawler scraped and triggers a fresh scrape (source). Meta notes that updating the image doesn’t automatically update the preview on old shares.

LinkedIn

LinkedIn’s help page says a preview may show an old cached image when a URL has been shared before, and that Post Inspector refreshes it: open it, enter the URL, and confirm the preview is correct. The change only affects new posts. Existing posts with that URL stay as they were (source).

Slack

Slack says responses are cached globally across the service for around 30 minutes (source). It documents no refresh tool, so wait and paste the link again.

X and Discord

We found no cache duration or refresh procedure we could verify in either platform’s own documentation, so there’s none to pass on here. Changing the image URL is the step to try first.

• Relative image URL. content="/og.png" or a path built without the domain.
• Wrong host. The tag points at localhost, a staging domain or a preview deployment that requires a login.
• Blocked by robots.txt. Meta’s crawler documentation says a robots.txt disallow is how you block its crawlers, so a blanket Disallow: /, or one that covers your image folder, does exactly that (source). Slack is different: it states that it does not currently honor robots.txt.
• Blocked by a firewall or bot rule. Meta publishes its crawlers’ user agent strings, starting with facebookexternalhit/1.1, and suggests allowlisting them or its IP addresses (source). Slack’s is Slackbot-LinkExpanding 1.0.
• Not an image. The URL redirects to a sign-in page, returns a 404 page, or is served with a content type that isn’t an image.
• Too large or too small. Over a platform’s file limit, or under the dimensions listed above.
• Tags only in the rendered page. Present in the browser’s inspector, missing from the page source.

1. Ask your server for the page the way a crawler does, and look for the tag in what comes back:

   curl -s -A "facebookexternalhit/1.1" https://yoursite.com/ | grep -i "og:image"

2. Request the image URL from that tag and read the headers. You want a 200 status, an image content type and a size under the limits:

   curl -sI https://yoursite.com/og.png

3. Run the page through the social preview checker. It reads the Open Graph tags and twitter:card, downloads the image, and reports whether it loads, its format, file size and pixel dimensions, and how far its shape is from 1.91:1. It also draws four common card layouts so you can see what gets cropped.
4. If your own server is sending the right thing, the stale copy is on the platform. Change the image URL if the file changed, then use the Sharing Debugger for Facebook and Post Inspector for LinkedIn.
5. Share the link in a new post or message. Old ones keep the old card.

What to put in the image is covered in launch listing visuals.