Twitter Card Validator
X retired its own Card Validator in 2022. Enter a URL to check twitter:card, see which tags X is really reading through the Open Graph fallback chain, and confirm the card image actually loads.
Short answer
A Twitter card validator reads the meta tags on a URL and reports what X will render when someone shares it. X retired cards-dev.twitter.com/validator in 2022 and never replaced it, which is why so many guides still link to a page that errors. Two rules decide the result. twitter:card is the only tag with no Open Graph equivalent, so without it X renders a small square thumbnail rather than the wide image. Every other field falls back to og:title, og:description and og:image, so a page with no twitter: tags at all can still render a perfect card. This tool fetches the URL as a scraper would, resolves that fallback chain field by field, and checks that the image actually loads.
There is no official validator any more
X shut down its Card Validator in 2022 along with most of the old developer tooling. Nothing replaced it. The result is that the top results for "twitter card validator" still point at a URL that returns an error, and the advice built around it assumes a preview you can no longer generate.
What is left is reading the tags and knowing the rules. That is a smaller job than it sounds, because X's behaviour is well defined and has not changed: one tag controls the layout, and every other field falls back to Open Graph. The part worth automating is the fallback chain, since that is where a page looks broken on paper and renders fine, or looks complete and renders blank.
Worth separating from the tags that feed search while you are here. A title tag and a meta description are what Google reads; the twitter: and og: tags are what every social platform reads, and the two sets are edited in the same place and serve different readers. Our SEO checklist for blog posts walks through both.
The practical consequence
You cannot force a cache refresh either. X holds what it scraped for about a week, and the button that used to clear it went with the validator. Check the tags before you publish rather than after, because after is when your options run out.
Which tags X actually reads
Most card checkers list the twitter: tags and mark the absent ones as failures. That reports a page with excellent Open Graph markup as broken, and it is the reason those tools get ignored. X resolves each field in order and only the first one that exists is used.
| Field | X reads, in this order | If nothing is set |
|---|---|---|
| Card layout | twitter:card only | Defaults to the small summary card. No Open Graph fallback exists |
| Title | twitter:title, then og:title, then <title> | The card shows the bare URL |
| Description | twitter:description, then og:description, then meta description | The card body renders empty |
| Image | twitter:image, then og:image | No image, and the card collapses to a plain link |
| Image alt | twitter:image:alt, then og:image:alt | The card is unreadable with a screen reader |
| Attribution | twitter:site and twitter:creator | No attribution line. Does not affect whether the card renders |
Read down the middle column and the practical advice falls out of it: set twitter:card, set good Open Graph tags, and skip the rest unless you genuinely want a different title on X than everywhere else. This tool prints which source filled each field, so a missing tag that does not matter is visibly different from one that does.
Why a card that should work does not
When the tags look right and the card is still wrong, it is almost always one of these five, and none of them is visible in the markup alone.
- The image URL is relative. A path like /images/card.png is legal HTML and resolves in a browser, and no social platform resolves it. It has to be the full absolute URL
- The image 404s, or sits behind a login, or is served from a host that blocks unfamiliar user agents. The tag is present, the file is not, and the card renders with no image
- The tags are added by client-side JavaScript. A scraper reads the server response and does not run your JavaScript, so a card built by a framework at runtime does not exist as far as X is concerned
- The page or the image is disallowed in robots.txt. Scrapers respect it, so a blocked path is a blank card
- The card was scraped before the tags were right, and the old version is cached for about a week
The image check is the part a markup validator cannot do
Reading tags out of HTML tells you the URL is there. It cannot tell you the URL works. This tool requests the image, reports the status code and content type, and flags the case where a URL ending in .png quietly returns an HTML error page, which renders exactly like having no tag at all.
How to validate a card without the official tool
Six checks in the order that finds problems fastest. The tool runs all of them; the sequence matters when you are working through a page by hand.
- 01
Check twitter:card before anything else
It is the one tag with no Open Graph equivalent, so nothing fills the gap when it is missing. Without it X renders a small square thumbnail instead of the wide image, which is the single most common reason a card looks wrong.
- 02
Work out which tags X is actually reading
X falls back to Open Graph for the title, description and image whenever the twitter: version is absent. A page with no twitter:title at all can render a perfect card, so a missing tag only matters when nothing behind it fills the gap.
- 03
Confirm the image URL resolves
A well-formed tag pointing at a 404 renders exactly like no tag at all. The URL must be absolute, must return an image content type, and must be reachable without a login.
- 04
Check the image against the card type you asked for
summary_large_image wants a wide image, roughly 2:1 and at least 300 by 157 pixels. A square logo in a wide card is letterboxed with bars down both sides, which is legal markup and still looks broken.
- 05
Read the title and description at X's widths
X cuts the title at about 70 characters and the description at about 125. Nothing rejects a longer string, it just disappears mid-word in the timeline, which is why a card can pass validation and still read badly.
- 06
Re-check after the page is live, not before
Tags are read from the HTML the server returns. Anything injected by client-side JavaScript is invisible to a scraper, so a card that works in your browser can still be blank in the timeline.
Where the other two tools fit
For a page that is not live yet, the Open Graph preview takes pasted markup and renders the same audit with no network request. For a live URL where you care about every platform rather than X specifically, the Open Graph checker reads the same tags and reports them against Facebook, LinkedIn, Slack and Discord as well.
What this tool checks
twitter:card
The one tag with no Open Graph fallback, and the usual reason a card is small
The fallback chain
Which of twitter:, og: or the page title fills each field X renders
Card image loads
The image URL is requested, not just read, so a 404 behind a valid tag is caught
Absolute URLs
Relative image paths, which are legal HTML and render on no platform
Card type validity
Values outside summary, summary_large_image, app and player
Title and description widths
Against the roughly 70 and 125 characters X renders
Image alt text
twitter:image:alt or the og:image:alt behind it
Attribution handles
twitter:site and twitter:creator, including the missing @
Redirects
The chain followed to the page whose tags were finally read
A card is scraped once and cached for about a week
Frequently asked questions
What happened to the official Twitter Card Validator?
X retired cards-dev.twitter.com/validator in 2022, and it has not been replaced. That is why so many guides link to a tool that now returns an error page. There is no first-party validator any more, so checking a card means reading the tags yourself and knowing which ones X falls back to. That is what this tool does: it fetches the URL as a scraper would, reports every tag involved, and resolves the fallback chain so you can see what X will actually render.
Why is my Twitter card not showing?
In order of how often it is the cause: there is no twitter:card tag and no og:image, so there is nothing to build a card from; the image URL is relative rather than absolute, which no platform resolves; the image returns a 404 or sits behind authentication; the tags are injected by JavaScript and the scraper never runs it; or the page is blocked to bots in robots.txt. This tool separates those cases, because the fix for each is different and a validator that only says "no card" tells you nothing.
Do I need twitter: tags if I already have Open Graph?
Mostly no, with one exception. X reads og:title, og:description and og:image whenever the twitter: equivalent is absent, so a page with good Open Graph markup renders a good card with no twitter: tags at all. The exception is twitter:card itself, which has no Open Graph equivalent. Without it X defaults to the small summary layout, so the one tag genuinely worth adding is twitter:card set to summary_large_image.
What is the difference between summary and summary_large_image?
They are the two card layouts that matter for ordinary pages. summary puts a small square thumbnail to the left of the title and description. summary_large_image puts a full-width image above them, which takes several times the vertical space in a timeline and is what most people picture when they think of a link card. The other valid values, app and player, are for mobile app listings and embedded media. Anything else in the tag is invalid and X falls back to rendering a plain link.
What size should a Twitter card image be?
For summary_large_image, aim for 1200 by 628 pixels, which is roughly the 2:1 ratio X wants and the same asset that works for Facebook and LinkedIn. The documented minimum is 300 by 157 and the maximum file size is 5 MB. For the small summary card the image is cropped square, so anything with text along the edges loses it. If you are only making one image, make it 1200 by 628 and keep the important content in the middle.
How do I refresh a Twitter card after changing the tags?
X caches what it scraped for about seven days, and with the validator retired there is no button to force a refresh any more. The workaround most people use is to share the URL with a cache-busting query string, which X treats as a new URL and scrapes fresh. That confirms the new tags are correct but does not clear the cache on the original URL, which expires on its own. This is a good reason to check the tags before a launch rather than after.
Does this tool post to X or need my account?
No. It fetches the URL over plain HTTP and reads the meta tags out of the HTML, the same as any scraper. There is no X account involved, no API key, and nothing is posted anywhere. That also means it can only see what the server returns to an anonymous request, which is exactly the constraint the real scraper works under.
Why does the tool say a tag is missing when my card works?
Because a missing tag and a broken card are different things, and this tool reports both rather than collapsing them. If twitter:title is absent but og:title is set, the card renders correctly and the tool says so: it shows the field as filled and notes that it falls back to Open Graph. The only absences reported as errors are the ones with nothing behind them, which is the distinction most card checkers miss.
Can I check a page that is not published yet?
Not with this tool, because it has to fetch the URL. For tags that only exist on your machine, on a staging host behind a login, or in a template you have not deployed, use the Open Graph preview instead: it takes pasted markup and renders the same audit with no network request. The two tools exist for that split, and between them they cover a page before and after it goes live.
Does twitter:site have to be set?
No, and it does not affect whether the card renders. It names the account the content belongs to, which X shows as an attribution line on some surfaces, and it needs to start with an @ to be read. twitter:creator does the same for an individual author. Both are worth setting on a publication with named writers and are safe to skip on a product page.
Other on-page SEO tools
Canonical Tag Checker
Validate canonical tags for self-referencing, protocol mismatches, trailing slash conflicts, noindex conflicts, and og:url consistency.
Use toolHreflang Validator
Validate hreflang tags for international SEO: self-referencing, return tags, x-default, language codes, and duplicate detection.
Use toolSchema & JSON-LD Validator
Validate structured data markup: required properties, date formats, nested entities, and JSON syntax. Supports all major schema types.
Use toolMeta Tag Checker
Check title tags, meta descriptions, Open Graph tags, Twitter cards, canonical URLs, robots directives, and viewport settings.
Use toolMeta Tags Generator
Write the title, description, and social share tags every page needs. Live character counts plus previews of how it will look in Google and on social.
Use toolKeyword Density Checker
See which words and phrases your copy actually leans on. Single word, two word and three word counts with density and first-mention position.
Use toolSERP Snippet Preview
See your title and meta description the way Google renders them, measured in pixels. Desktop and mobile, with the exact character your snippet is cut at.
Use toolURL Slug Generator
Turn a list of page titles into clean, readable URL slugs. Accents transliterated, filler words optional, and duplicates caught across the whole list.
Use toolAnchor Text Generator
Build branded, partial, long tail and naked URL anchor variations for any page, then audit the anchors you already have against a natural distribution.
Use toolReadability Checker
Score any text on six readability formulas at once, then see which sentences are dragging the grade up. Passive voice and long sentences broken out separately.
Use toolPage Word Counter
Count the words on any URL, with the body copy separated from the nav, header and footer. Unique words, reading time, paragraphs and the heading outline.
Use toolImage Alt Checker
Audit the alt text on every image on a page. Missing attributes kept apart from decorative alt="", plus image links with no name, filenames used as descriptions and duplicates.
Use toolOpen Graph Preview
Paste your meta tags and draw the card each platform renders, cut where it really cuts. Works on staging and on tags you have not deployed yet.
Use toolOpen Graph Checker
Fetch a live URL and read its og: tags the way a scraper does, then check the card image actually loads rather than only that the tag exists.
Use toolRead up on on-page content
A tool tells you what is wrong. These explain what to do about it.
Google March 2026 Spam Update: Fastest Rollout Ever (19.5 Hours) — What Was Targeted & How to Recover
Read guideSurfer SEO Review 2026: Is It Worth $79/Month? (Honest Verdict)
Read guide7 Best Surfer SEO Alternatives for Deep Site Audits & Content Optimization (2026)
Read guideCheck every page's card, not one at a time
A missing twitter:card or a broken image usually comes from a template, which means it is wrong on every page using that template rather than the one you happened to test. CrawlRaven crawls the site, records the social tags on every page, and joins them to Search Console so you can see which of the pages with no card are the ones actually earning traffic.