The OG Image Size That Works on Every Platform
If you have ever pasted a link into Facebook, Slack, or Discord and watched a tiny, cropped, or completely missing picture show up instead of the graphic you spent an hour designing, the problem almost always comes down to og image size. Here is the short answer before we get into the why: make your og:image 1200 by 630 pixels, keep the aspect ratio close to 1.91:1, and keep the file under 1MB. Do that and your preview looks right on nearly every major platform, on the first try.
The rest of this article explains where that number comes from, where it breaks down, and exactly what to check when your image still looks wrong after you have done everything "right."
What Size Should an OG Image Be?
An og:image is one line in a web page's code, sitting inside the invisible <head> section. It tells any platform that unfurls (expands) your link which picture to show. Think of it the way an airline thinks of a passport photo: there is no single international law dictating the exact millimeters, but every airline has quietly converged on roughly the same shape because it works at their check-in kiosk.
Open graph image size works the same way. The protocol itself, documented at ogp.me, does not mandate any dimension at all; it just says og:image should be "an image URL which should represent your object." Every pixel number you will read, including the ones in this article, is a platform convention that grew up around that open rule, not a web standard.
Facebook is the one platform that actually publishes numbers, and because Facebook (Meta) was early and influential, most other platforms quietly adopted a version of its recommendation. According to Meta's own sharing documentation, the absolute floor is 200 by 200 pixels, below which Meta may reject the image outright. To get the large image card instead of a small thumbnail, your image needs to be at least 600 by 315 pixels.
The recommended size, and the one worth designing to, is at least 1200 by 630 pixels, described by Meta as ideal "for the best display on high resolution devices." That phrase matters: 1200 by 630 is the size that keeps your image sharp on a retina display, the same way a photo meant for print needs more resolution than one meant only for a phone screen.
So there are really three tiers, not one number: 200x200 is the bare minimum that avoids rejection, 600x315 is what triggers the large card instead of a thumbnail, and 1200x630 is the recommended target that looks crisp everywhere, including on high-density screens. When people search for open graph image size, they usually mean that third number, and that is the one to build for.
The platform-by-platform size cheat sheet
Here is where the "just use 1200x630" advice gets a little more honest. Og image dimensions are not identical across platforms; they cluster around the same family of numbers, with a few platforms nudging the ratio or the minimum in their own direction. The table below marks which numbers come from an official source and which are industry convention, because those are two different levels of certainty.
| Platform | Recommended size | Minimum size | Aspect ratio | Status |
|---|---|---|---|---|
| Facebook / Meta | 1200 x 630px | 600 x 315px (200 x 200px floor) | 1.91:1 | Official (Meta Sharing docs) |
| X (formerly Twitter) | 1200 x 628px | ~300 x 157px | ~1.91:1 to 2:1 | Widely reported, not officially confirmed (see note below) |
| 1200 x 627px | Not published | ~1.91:1 | Industry convention | |
| Discord | 1200 x 630px | ~400px wide for the large card | 1.91:1 | Observed product behavior |
| Slack | 1200 x 630px | Not published | 1.91:1 | No unique Slack spec; same safe default applies |
| iMessage / WhatsApp | 1200 x 630px | Falls back to your site icon if missing | 1.91:1 | No dedicated size documentation |
A quick honesty note on that X row. As of this writing, X's own Cards developer documentation returns dead links or paywall errors rather than a working spec page. The 1200x628, 300x157, and ratio figures above are what several independent developer write-ups converge on, not a number pulled from a live X-owned page. Treat them as "commonly cited," the way you would treat a recipe that three food blogs all swear by even though none of them got it from the restaurant.
LinkedIn is similar in spirit: it does not publish a dedicated og:image size specification the way Meta does. The 1200x627 figure floating around the web is an industry convention built on the same 1.91:1 family as Facebook's number, not a LinkedIn-issued rule. LinkedIn does publish official guidance on its Post Inspector tool, which is worth using to check how LinkedIn currently reads your tags; our Open Graph tags guide, linked further down, covers it in more depth.
Open Graph image dimensions and aspect ratio: why 1.91:1 wins
Aspect ratio is just a fancy way of describing the shape of a rectangle: width compared to height. A ratio of 1.91:1 means the image is nearly twice as wide as it is tall, closer to a widescreen TV than an old square television set. When a square photo gets forced onto a widescreen frame, something has to give: either the platform crops the sides off, or it shrinks the whole picture and pads it with empty space. Neither looks good.
That is exactly what happens to your og:image when its open graph image dimensions do not match the 1.91:1 family. A perfect square (1:1) gets center-cropped on platforms that expect a wide rectangle, often cutting off a logo or a face at the edges. A tall portrait image fares even worse, since most social platforms assume a landscape shape. Designing at 1200x630 from the start sidesteps the whole problem, because you are handing every platform the shape it already expects.
If you want to give platforms extra confidence about your image's shape, you can declare it explicitly with two optional tags, a practice Meta's own sharing best practices guidance recommends so the crawler can render the image without downloading it first:
<meta property="og:image" content="https://example.com/social-share.jpg" />
<meta property="og:image:width" content="1200" />
<meta property="og:image:height" content="630" />These width and height properties are optional per the Open Graph protocol, but including them lets a platform display your image faster, since it does not have to download the file first just to figure out its dimensions.
Why your thumbnail looks tiny instead of the big image
This is the complaint that sends most beginners searching in the first place: the image is there, just small and off to the side, instead of the big banner-style preview you expected. Developers often describe this as the platform "ignoring" their image, and that is close to the truth. The image is not rejected; it is downgraded to a smaller display slot because it did not clear a size or shape threshold.
On Facebook, this downgrade happens for two main reasons. First, your image sits below the 600x315 pixel threshold that triggers the large card, so Meta falls back to a thumbnail treatment instead. Second, and this one surprises people, a perfectly square image can also trigger the small-thumbnail layout even if its pixel count is technically large enough, because Facebook's large-card display is built around that 1.91:1 shape, not just a minimum pixel count.
Discord works on a related but distinct rule. Whether Discord shows a large image below your link preview or a small square thumbnail beside it depends heavily on the twitter:card value in your page's tags. Set it to summary_large_image (paired with a wide image) and Discord tends to show the big version. Leave it as summary, or omit it, and Discord defaults to a small side thumbnail, roughly 80 by 80 pixels, regardless of how large your image file is.
This is observed product behavior corroborated by multiple independent developer reports rather than an official Discord specification page, since Discord's public API docs cover bot embeds, not the link-preview behavior you see when a person pastes a URL in chat.
One more thing worth knowing: size is not the only reason a preview looks wrong. Developer Alvaro Montoro documented a case where his og:image tag was correct, and X and LinkedIn picked it up fine, but Facebook kept showing a stale, generic image. The cause was that Facebook indexes shared links by og:url and had a cached lookup pointing at the wrong page.
If your image size and ratio check out but the preview still looks wrong on one platform specifically, a stale cache or a mismatched og:url is worth checking before you touch the image again. You can read his full account of that bug for the exact debugging trail.
What is the maximum OG image file size (and why smaller is better)
File size and pixel dimensions are two different things, and beginners often only think about the second. Pixel dimensions describe the shape and sharpness of your image. File size, measured in kilobytes or megabytes, describes how much data that image takes up on disk, and that number matters just as much for a working preview.
Meta's own documentation caps og:image files at 8MB. X's cap is, again, not confirmed against a currently reachable X-owned page, but independent sources consistently report a 5MB ceiling. Those are the hard walls, the point at which a platform refuses the image. Treating either number as your target is like packing a suitcase right up to the airline's weight limit: technically allowed, but one snack away from a problem, and here the "problem" is a crawler that times out before it ever downloads your image.
The practical target, whichever platform's cap applies, is under 1MB. Most well-compressed JPEGs or WebP files at 1200x630 land comfortably in the 100 to 300KB range without visible quality loss, which leaves a wide safety margin under every hard limit while loading fast enough that a crawler with a short timeout does not give up. A photo editor's "export for web" setting, or a free tool like Squoosh, gets you there in seconds.
Checking your own OG image size and ratio
Reading about pixel thresholds is one thing. Knowing whether your own image actually clears them is another, and that is exactly what our Open Graph checker was built to answer.
- Go to socialpreview.tools and paste in the URL of the page whose preview looks wrong. Click check. You should see preview cards render for Facebook, X, LinkedIn, Discord, Slack, and iMessage, along with a graded report. If the page fails to load at all, double check that the URL is public (not password protected or blocked from outside visitors), since the checker fetches the page the same way a real crawler would.
- Look at the image findings section for flags like "image under 1200," "image square," or "image over 1MB." Each flag corresponds to one of the thresholds covered above, so you will know exactly which number your image is missing. If you see no image findings at all, your current og:image already clears every threshold the tool checks against.
- Fix the flagged issue (resize, recompress, or reshape the image) and re-check the same URL. If the report still shows the old image after you have uploaded a new one, that is very likely a caching issue on the platform's end, and it is worth clearing that platform's cache before assuming your fix did not work.
If you do not have an og:image tag at all yet, or you want to build one from scratch with the right width and height attributes already filled in, our tag generator builds the full set of Open Graph and Twitter Card tags with a live preview, so you can see exactly how the image will look before you publish anything.
A quick troubleshooting checklist
Before you assume a broken preview is a size problem, run through this short list. In practice, these four causes cover the overwhelming majority of "my image won't show up right" reports:
- Wrong aspect ratio: a square or portrait image getting awkwardly cropped by a platform expecting 1.91:1.
- File too heavy: an image technically under a platform's hard cap but large enough that a crawler times out before finishing the download.
- A relative image path: an og:image value like
/images/share.jpginstead of a full URL starting withhttps://, which many platforms simply cannot resolve. - The image itself is blocked: sitting behind a robots.txt disallow rule, a login wall, or a redirect chain the platform's crawler will not follow.
If your image size and file weight both check out and the preview is still wrong, the issue is usually elsewhere in your tag setup. Our full Open Graph tags guide walks through every tag, what it controls, and how to force platforms to refresh a cached preview once you have fixed the page. And if you want to confirm the image file itself loads correctly and reports the right format outside of any social context, a general image checker like imagecheck.tools is a useful second opinion.
Frequently Asked Questions
What size should an og:image be?
Aim for 1200 by 630 pixels with an aspect ratio near 1.91:1, saved as a JPEG or WebP file under 1MB. That size sits comfortably above every major platform's minimum threshold, displays sharply on high-resolution screens, and matches the shape most platforms expect for their large preview card, so you get the good-looking version of the preview instead of a cropped or downgraded one.
Does 1200 by 630 work on every platform?
As a safe default, yes, and it is the single best number to design to if you only want to remember one. The exceptions worth knowing are X, which tends to center-crop images that do not match its preferred ratio a little more tightly, and Discord, where the large-versus-small display depends on your twitter:card value as much as on pixel dimensions. Designing at 1200x630 avoids nearly every failure case; it just is not a guarantee on every platform, because none of them coordinate their rules with each other.
Why does Facebook show a small thumbnail?
Facebook downgrades to a small thumbnail display when your image falls below the 600 by 315 pixel threshold needed for the large card, or when the image is a perfect square, since Facebook's large-card layout is built around the wider 1.91:1 shape rather than pixel count alone. Uploading a new image sized at 1200x630 and confirmed as landscape, not square, resolves the vast majority of small-thumbnail cases.
What is the maximum og:image file size?
Meta's own documentation caps og:image files at 8MB, and X is widely reported to cap files around 5MB, though that number is not confirmed against a currently live X-owned specification page. In practice, neither hard cap is the number to design to. Keeping your file under 1MB, which a well-compressed 1200x630 JPEG or WebP achieves easily, avoids crawler timeouts and slow-loading previews regardless of which platform's specific ceiling technically applies.