og:image vs twitter:image: Which Image Wins on Share Cards

Contents
When you paste a link into KakaoTalk or Slack, the preview card shows a featured image. But sometimes the same address shows one image in KakaoTalk and a different one on Twitter (X). That's not an optical illusion — the page declares two separate tags, og:image and twitter:image, so the difference is real.
This post covers which of the two tags actually takes priority, and how to check for yourself which featured image a page declares without opening any code. If you found this page by searching for "og:image download" or "featured image extractor," what you often need first isn't how to save the image but which image is the real featured image.
Summary ① Most sharing services — KakaoTalk, Facebook, Slack, and others — look for og:image first, and only fall back to twitter:image when og:image is missing. ② When a page declares more than one featured image tag, the image each service actually shows can differ. ③ You don't have to dig through page source. Enter one URL and you can see the featured image that page declares, exactly as declared.
Why the same address shows a different image on each platform
When you're gathering articles from other sites to reference in a blog or newsletter, you run into pages where the featured image on a KakaoTalk share and the one on a Twitter (X) share are different.
You copied and pasted the same URL, yet each platform shows a different picture, so it's hard to tell which one is the page's "real" featured image. You can't even decide whether one of them is wrong or whether this is simply how it's designed.
Opening developer tools to check the page source only makes it look messier. Inside the head tag there's an og:image tag and a twitter:image tag, each declared separately, and some pages really do have different content values (image URLs) for the two. Looking at the code alone won't tell you which tag to go by, or why anyone would bother declaring two separate image tags in the first place.
The same problem comes up in content planning and competitor research. You want to collect featured images from several sites as references, but every page puts its tags in a different place, so you end up opening developer tools and hunting by eye every time. If you don't know the difference between og:image and twitter:image, you have to decide all over again which image to record as "that page's featured image," and the criteria behind your research start to drift.
One image tag would be easy enough, but once you hit a page with two or more, you have to figure out which one is actually used before you can move on, and your research slows down noticeably.
Part of the reason this confusion happens is that many people assume og:image is the only featured image tag there is. If og:image is all you know, the existence of a separate twitter:image tag feels unfamiliar, and the possibility that the two values could differ is even harder to imagine. Then, when you do run into a page where they differ, you're stuck with no standard for deciding which one is correct.
This problem doesn't only come up when you're researching someone else's site. Share your own old blog or company page today and you can hit the same confusion. When you switch templates or migrate a CMS, people really do add a new og:image and leave twitter:image on its old value, and then KakaoTalk shows the new image while Twitter (X) shows the old one — two different results on your own site.
The same thing repeats in day-to-day newsletter and curation work. When you build intro cards from links across many sources, not knowing that each link's featured image shows up differently by platform means the screen you previewed and the screen after publishing don't match.
The bigger your operation, the more this stands out. If you're a marketer managing multiple product or campaign pages, checking by hand that every page has both og:image and twitter:image is hard. As a result, it's easy to leave things as they are while one page shows the image you want on KakaoTalk and an old image or just the logo on Twitter (X), giving each channel a different impression.
What makes this trickier is that you can never spot the mismatch just by opening the page. Whether it's og:image or twitter:image, the browser shows the same body text with no visible difference, so until you actually share the link or check each tag, it's hard to even notice there's a problem.
How to check the page source yourself
Let's start with checking it yourself. On the page you want to inspect, right-click and open "View Page Source" (Ctrl+U on Windows, Cmd+Option+U on Mac). Then search for og:image with Ctrl+F (Cmd+F on Mac).
If you find a line in the form meta property="og:image" content="...", the address inside content is the first preview image that page declares. Next, search for twitter:image as well. If there's a separate meta name="twitter:image" content="..." line, that page has set two different images.
If the addresses in both tags are exactly the same, you don't need to think any further. The trouble starts when they differ. In that case, copy each URL into a new tab and open them one by one so you can compare what each image actually looks like.
If an address is written as a relative path (something like /images/thumb.png), you have to put the domain in front of it before a browser will open it. For example, if you find a relative path like that on an example.com page, you have to assemble it by hand as https://example.com/images/thumb.png.
There's one more thing to watch for. Some sites don't include the og:image tag when the server delivers the page; they add it only after JavaScript runs. On those pages, og:image won't appear in the raw HTML you see in "View Page Source", but it may appear in the current DOM under the "Elements" tab in developer tools.
That difference is what creates the confusion of "I was told the tag is definitely there, but it's not in the page source." To be sure, it's safest to open both View Page Source and the Elements tab in developer tools and compare them. That said, crawlers from sharing platforms such as KakaoTalk and Facebook often don't run JavaScript and only read the HTML they first download, so the value that actually ends up on the share card is usually closer to what you see in View Page Source.
If you want to see the real result, you can also paste the link into a chat room only you can see, like KakaoTalk's "Message Yourself", and check which card actually appears. Keep in mind that this method may simply show a result KakaoTalk cached earlier, so it won't always match the current value in the page source exactly.
It's also worth knowing that mobile browsers often don't have View Page Source in their default menu. If you need to check in a hurry on your phone, putting view-source: in front of the address in the address bar works in some browsers, but comparing tags reliably is much easier on a desktop browser.
To feel how heavy this process gets, imagine you have to check several sites at once. Say you need to gather the preview images for a few sites you're collaborating on: you'd open the page source on each site, search for og:image and twitter:image, and convert relative paths into absolute ones, over and over. Even if checking a single site takes only a few minutes, that time keeps piling up when you have several to get through.
For one site, this method is enough. But when you're going through several sites back to back, or you keep having to build relative paths by hand, it gets tedious fast. Just eyeballing, page after page, whether og:image and twitter:image are both there, whether the values match or differ, and whether a tag is injected later by JavaScript takes quite a while even with only a handful of sites.
Free · no sign-up · just enter a URL and it finds the page's preview image and saves the original file as-is

Put an address into this tool and it finds every preview image candidate the page declares — og:image, twitter:image, and others — lists them all at once, and even lets you save the original file exactly as it is. No opening the page source, hunting down tags one by one, or assembling relative paths by hand. One address and you're done.
Each image it finds comes with "Open" and "Save" buttons. "Open" shows the original image in a new tab, and "Save" downloads the file right away, replacing the manual routine of opening candidate images one at a time to compare them.
Why og:image gets checked before twitter:image
To understand why two separate tags like og:image and twitter:image exist at all, and why one of them ended up with priority, you have to start with who actually reads these tags.
Most services that build a preview card when you share a link — a messenger app such as KakaoTalk or WhatsApp, Facebook, Slack — look for the og:image tag first. They fall back to twitter:image only when og:image is missing. In other words, og:image is effectively the "default," and twitter:image is closer to a "backup" for when that default isn't there.
The "og" in og:image stands for Open Graph, a metadata spec for link sharing. Because that spec is so widely supported across platforms, even services with their own card spec ended up referencing twitter:image as a fallback when og:image is missing, and that's how og:image became the de facto default.
For reference, the screen you see when you open a link directly in a browser and the preview card you see when you share it to a messenger or social network are built through completely different paths. The browser renders and displays the whole page. A share card isn't the whole page — it's a small card rebuilt from a handful of preset tag values like og:image and twitter:image. That's why even after scanning a page carefully, you often can't spot the representative image visually, and the only way left is to check the tags themselves.
That's where the reason to fill in both tags comes from on the publishing side. Declaring og:image correctly is enough for previews to work on most services. But you also declare twitter:image as a kind of safety net in case something exceptional happens and a service fails to read og:image.
It's also why many sites put the same image URL in both tags. If the same picture comes out no matter which one gets read, you remove the worry of different cards on different platforms before it starts.
The problem is pages that put different image URLs in the two tags. These pages do exist, and that means a single page is declaring more than one candidate for its representative image.
In fact, if you analyze a github.com address with this tool, you'll see one PNG file under the og:image label and, separately, a second representative image file in JPG format. So there really are pages that declare more than one candidate for the representative image, and in those cases which candidate each service picks becomes a question of priority.
On a page with multiple candidates like that, services that check og:image first show the og:image picture, and if some service exceptionally checks a different value first, that service may show a different picture. Seeing a different card image for the same shared URL depending on where you view it isn't an optical illusion — it's the result of the page declaring things that way in the first place.
This priority story only holds if the og:image value itself points to the correct, current image. A preview that still shows the old image right after a deploy is a separate phenomenon with a different cause. It isn't that the tag value is wrong — services like KakaoTalk or Facebook store the result they read once in their own cache and reuse it.
Some pages have neither tag. A page built long ago, or one built without giving any thought to a representative image, may declare neither og:image nor twitter:image. If you analyze a page like that with the tool, you get a result saying no image was found. That doesn't mean the tool failed — it means the page has no representative image tag to reference in the first place.
It's worth distinguishing a page with no tag at all from one where the tag exists but the value is left empty. If the content value is empty, the tag exists but the practical result is the same as having no image to point to, so those pages are also treated as having no image found. The test isn't whether the tag exists, but whether it actually holds a valid value.
If you can just tell these three results apart — og:image found, replaced by twitter:image, neither present — then whatever page you run into, you can sort the representative image situation into one of three buckets. Even a problem that looks complicated is ultimately something happening inside this simple branch.
To sum up, the priority goes in three steps: og:image first, twitter:image second, and no representative image if neither is there. Once you know that order, you can explain why the same link looks different on different platforms, and why a representative image doesn't show up at all on a certain page, without knowing any code.
Knowing this priority also makes it clear what to fill in first when you run a page yourself. If you're short on time and can only manage one tag, filling in og:image correctly first is the efficient choice. twitter:image is the second line of defense for when og:image fails, not the tag that gets checked more often day to day.
On the other hand, if you've already filled in both tags, it's easier to manage and easier to predict if you unify them on the same image URL, unless you have a strong reason to keep the values different. The more the two values differ, the more cases there are where the result depends on which platform you're viewing from.
For someone doing research, the result matters more than the reason. Why a given page set different images in the two tags can vary from page to page, but which image is declared as og:image and which is declared as the remaining candidate right now is a fact you can check immediately with the tool. If you know the priority rule, that result alone is enough to predict which image will actually appear on the card.
If you're planning content by collecting representative images from multiple sites for reference, this priority matters even more. Instead of agonizing each time over whether to use og:image or twitter:image as the basis for each site, set og:image as the reference value every time and check twitter:image as a secondary only when needed. Standardizing your research order that way keeps your comparisons consistent across sites.
og:image vs. twitter:image
Here's a table summarizing how the two tags differ.
| Item | og:image | twitter:image |
|---|---|---|
| Check order | Most services check it first | Generally checked only when og:image is missing |
| Role | The de facto main preview image | A backup image in case there's no default |
| When both are declared | Actually shows up on most share cards | Not used on most cards — it stays on standby |
| When neither exists | Shows "No image found" | Shows "No image found" |
| When the values are the same | Common practice (a safety net) | Common practice (a safety net) |
| File format | Varies by page (no strict spec — PNG, JPG, and so on) | Varies by page (no strict spec — PNG, JPG, and so on) |
| When the values differ | Different services can actually show different images | Different services can actually show different images |
| When the URLs differ only by query string | May just be a version marker for the same image, but each is treated as a separate URL | May just be a version marker for the same image, but each is treated as a separate URL |
| When the protocol (http vs. https) is mixed | The tags may have been written at different times | The tags may have been written at different times |
The most important row in this table is "Check order." If you manage the page yourself, filling in og:image correctly alone covers most sharing situations — think of twitter:image as a backup for edge cases.
Conversely, if you're researching another site's preview image, the first step is to check whether the two values match. If they differ, that page deliberately prepared two different candidates, so you can use the priority order to judge which one is the image people actually see.
There's also a point worth making about image quality. When platforms like KakaoTalk or Facebook render a share card, they often compress or resize the original image to suit their own servers. That means the preview image you see on screen may not match the original in quality.
Files you save with the tool work differently — they're pulled straight from the address that the content value of the og:image and twitter:image tags points to. That's closer to the original file the page declared, not the compressed card version the platform generated. If your goal is research or archiving, that difference can genuinely matter.
Here's how to judge it in practice. If you care about most channels — KakaoTalk, Facebook, and the rest — use the og:image value as your baseline. If you get a report that a different image shows up only on Twitter (X) cards, then check the twitter:image value separately. That's the efficient order. And if you compare both values up front, you'll be able to pinpoint the cause no matter which platform has a problem later.
The moment this difference actually becomes a problem is usually when someone tells you "it looks wrong on one channel only." If it looks fine on KakaoTalk but wrong on Twitter (X), suspect twitter:image first. If it's the other way around, suspect og:image. If the two values are the same anyway, you'd never get that report in the first place — so you only need to worry about pages where they differ.
Common snags
Here are the snags people hit most often during research and checks. Most of the time it's not that you used the tool wrong — it's a natural result of how the page declared its tags.
| Symptom | Cause | Fix |
|---|---|---|
| og:image and a second preview image address show up as different | The page declares more than one preview image candidate | Open each result and judge by the order — og:image takes precedence |
| The tool shows "No image found" | The page has no og:image or twitter:image tags at all | There's no tag to fall back on — if you run the site, you'll need to add them |
| The image address won't open in a new tab | A relative path was left as-is, or the server blocks outside access | Recheck with an absolute path (a full address starting with https://) |
| The KakaoTalk preview doesn't update to the image you just changed | Not a tag issue — the sharing platform cached and reused the old result | Separate from priority; handle it with each platform's cache refresh tool |
| og:image exists but looks oddly cropped | The image's own aspect ratio (unrelated to tag priority) | Check the original image's actual dimensions and ratio |
| Analysis fails on a page that requires login | The tool can only read public pages, with no login session | Only public pages can be analyzed; private pages are out of scope |
| It's the same picture but the file size differs from og:image | The same image may be hosted in different places, such as the origin server and a CDN | Treat og:image as the reference value by priority, and open both files to compare if needed |
| The preview image is just a logo or default image | The site uses one shared default image as og:image instead of per-post images | That's a site-wide setup, not a page-level issue — the tool can only show you the current value |
Most items in the table stem not from a tool error but from which tags the page declared in the first place. If a result looks odd, start by confirming what the page's tags actually point to. The KakaoTalk cache issue is the one exception — it's a platform-side matter, not a tag problem, so no amount of fixing the tag values will solve it. That needs a separate cache refresh step.
What about copyright for downloaded images?
The images this tool retrieves are preview images the page has already declared publicly. It's not a feature that bypasses logins or private content — it only finds and shows images that anyone visiting the page can see. Pages with restricted access can't be read for tags in the first place, so they're naturally excluded from analysis.
That said, being visible on screen doesn't mean you're free to use it however you like. Copyright in the downloaded file still belongs to the person who created the image or the page's operator. Taking a quick look for content planning or competitor research and storing it for reference is a completely different matter from lifting that image into your own content.
If you actually want to use it, keep it within personal, lawful bounds — for example, it's your own upload, or you have clear permission from the copyright holder. Re-uploading or redistributing another site's preview image without any checks can amount to copyright infringement.
One more thing to keep in mind: the fact that an image is a public page's preview image doesn't mean you're free to do whatever you want with what's inside it. For instance, a personal blog's profile photo or a photo of a specific person might be set as the og:image, and those images can raise publicity rights issues on top of copyright.
Taking a quick look during research and planning is a very different thing from displaying that image in other content or redistributing it in a form that reveals the person. If you're planning commercial use in particular, it's safer to check with the original creator and with any person shown in the image.
For example, say you spot a preview image you like while researching a competitor's product page. Reusing it as-is for your own post or product page og:image is clearly a different matter. That's not reference — it's taking the original work, so avoid it without a separate license check or permission.
In short, this tool is closer to a research tool for quickly seeing, at a glance, which image a page has declared as its preview image. Where and how you actually use the image you find is something you need to decide separately after confirming the copyright situation.
How It Differs from Similar Tools
There are several other ways to check a preview image, and each one has a slightly different purpose. Even when the names look alike, a tool that checks and refreshes the tags on your own site is a different animal from a tool that finds and saves an image that already exists.
Facebook's Sharing Debugger and the cache refresh tool in Kakao's developer console are for checking whether the og tags on your own site are being picked up correctly, and for forcing that platform's cache to refresh when needed. You generally use these while managing a site you own, and they can't save images from someone else's site.
The Open Graph Preview tool on this same site is another different case. You enter a URL, and it shows you how tags like og:title, og:description, and og:image would actually render as a KakaoTalk card, and it points out any tags that are missing. In other words, it checks whether the tags on your site are all filled in properly.
The preview image downloader covered in this article, by contrast, focuses on finding and saving the actual image file that already exists. The question isn't how the tags render as a card — it's which file og:image and twitter:image each point to, and whether you can get that file in its original form.
Compared with digging through the page source in your browser's developer tools, this tool takes over the repetitive work of locating the tags and turning relative paths into absolute ones. The result is the same value that's already written in the page source. The tool doesn't invent an image that isn't there, and it doesn't swap in a different one.
It's also different from right-clicking the image on a share card inside KakaoTalk and saving it. That usually gives you a version KakaoTalk resized and compressed for the card, while this tool pulls the file straight from the original address the tag points to.
It's different from a screenshot, too. og:image often isn't a banner displayed large on the page — it's declared only in the page code, so you can scroll all you want and never spot it. This tool works from the value declared in the code rather than what's on screen, so it returns results a screen capture can't give you.
For reference, this site has a few other download tools with similar behavior but different goals. The one that collects every image on a web page into a single zip file targets all the images in the body, not just one preview image. The one that gathers site icons targets favicons and Apple touch icons used in browser tabs and on home screens, not og:image.
All three tools do basically the same thing — find images declared on a page and save them — but they target different tags and different kinds of images. If all you need right now is one preview image for share cards, this tool is the fastest. If you need all the image assets on a page, the bulk image downloader fits better. And if you need the icon used in browser tabs or bookmarks, the favicon downloader is the right pick.
Summary
Here's a recap of what we've covered. og:image and twitter:image both specify a preview image, but the order they actually get read in — and the role each plays — is clearly different.
- Most sharing services check og:image first and only fall back to twitter:image when og:image is missing.
- Pages where the two tags hold different values really do exist, and on those pages different platforms can show different preview images.
- A page with neither tag is correctly handled as "no image found" — that's not a tool error.
- To see whether the values match, you can open the page source yourself, or just enter one URL in the tool and check right away.
- Copyright in any image you find belongs to the original creator, so treat it as reference only and confirm permission before you actually use it.
The point, in the end, isn't which tags exist — it's which tag gets read first. Remember that order, and it stops being surprising when the same link looks different on different platforms, or when no preview image shows up at all.
Free · no sign-up · just enter a URL and it finds the page's preview image and saves the original file as-is
FAQ
Which matters more, og:image or twitter:image?
Most services check og:image first and use twitter:image only when it's missing. So if you're managing a single page, getting og:image right is the practically important part. If you set both to the same image, every service shows the same card, so unless you have a reason to keep them different, matching them is easier to manage.
Are there really pages where the two tags point to different image URLs?
Yes. Pages that declare more than one preview image candidate do exist, and on those pages a different picture can show up depending on which service you share to. Run the URL through the tool and you can see the difference right away without digging through the page source. If the values come out different, assume og:image is the one that wins on most channels.
What happens with a page that has neither og:image nor twitter:image?
The tool shows "No image found." That doesn't mean the tool failed — it means the page itself has no meta tag declaring a preview image. Share a page like that, and depending on the service you may get a card with no image, or some random image from the body may be used instead. If you run the page, adding an og:image tag is the surest fix.
I just changed the image, but KakaoTalk doesn't show it. Is that related to this article?
That's a different issue. The tag itself has changed, but a platform like KakaoTalk stored what it read earlier in a cache and is reusing it. That's a caching problem, not a tag priority problem, and you have to fix it separately with the cache refresh tool that platform provides. This tool shows you the current tag value as it is — it doesn't refresh a platform's cache.
Can I save images from other sites with this tool?
It's for checking and keeping images that are already visible on public pages, as reference material. Copyright in a downloaded file belongs to the original creator, so if it isn't your own material and you don't have the rights holder's permission, reusing or redistributing it can infringe copyright. Using it only as personal reference during research or planning is the safe approach.
How do I check an image URL that's a relative path?
If you find a relative path in the page source, such as /img/thumb.png, you have to put the domain in front of it to make an absolute path before a browser can open it. With the tool, you get results already resolved to absolute paths from the start, with none of that work — which is especially handy when you're checking several sites in a row.
How do I confirm my own site's og:image is declared properly?
This tool is more about finding and saving an image that already exists. To check whether your own site's tags are all declared and to see how the KakaoTalk card actually renders, the Open Graph Preview tool is a better fit. Use both together and you've covered tag checking and image saving.
This article was adapted from our Korean original. Read the Korean original