AnyTool
Your files never leave your device. All processing happens locally in your browser.

How do I preview and validate my X (Twitter) Card meta tags now that X removed its official Card Validator — without uploading my page to a server?

Open AnyTool&rsquo;s Twitter Card Validator, paste your page&rsquo;s HTML source (View Source / Ctrl+U) — or pick the card type and fill the small twitter:card / twitter:title / twitter:description / twitter:image / twitter:site / twitter:creator form — and it parses every twitter:* (and og:*) meta tag and renders a LIVE X/Twitter card preview that changes by card TYPE: a <strong>summary</strong> card shows a small ~1:1 image on the left with the title, description and domain, while a <strong>summary_large_image</strong> card shows a large 1.91:1 image above the title and description (with a graceful fallback when the image URL can&rsquo;t load). It VALIDATES against X&rsquo;s documented rules — twitter:card must be summary, summary_large_image, app or player; title and description lengths; the @handle format for twitter:site / twitter:creator; and image specs (absolute https, ~1200&times;628 for the large card, under 5 MB) — and flags every place where X falls back to your og:title / og:description / og:image, with a clear pass / warn / fix for each plus a raw parsed-tags table. Everything runs in your browser, so your HTML is NEVER uploaded — safe for staging pages. Honest caveat: X (Twitter) REMOVED its official Card Validator around 2022, so this previews + lints as an APPROXIMATION, not X&rsquo;s actual renderer; X falls back to Open Graph, caches cards, and renders differently across clients, so confirm the live card by posting on X.

  • Live X/Twitter card preview that changes by card type (summary = small ~1:1 image left; summary_large_image = large 1.91:1 image above title/description/domain)
  • Validates twitter:card (summary / summary_large_image / app / player), title & description lengths, @handle format, and image specs (absolute https, ~1200×628, under 5 MB)
  • Reuses the shared socialMetaEngine with the sibling Open Graph Checker; flags every twitter:* → og:* fallback X applies
  • 100% client-side — your HTML and tags are never uploaded; safe for staging pages, works offline once cached
  • Honest: X removed its official Card Validator (~2022), so this previews + lints as an approximation (not X’s renderer); X falls back to og:, caches, and renders differently across clients; paste source (CORS)

What is

Twitter Card (twitter:) meta tags and the X card

A Twitter Card (now an X card) is the rich link preview X builds from &lt;meta name="twitter:*"&gt; tags in a page&rsquo;s &lt;head&gt;. The only strictly required tag is twitter:card, whose value is one of summary, summary_large_image, app or player; twitter:title, twitter:description, twitter:image, twitter:image:alt, twitter:site (the @handle of the site) and twitter:creator (the @handle of the author) refine it. X FALLS BACK to your Open Graph tags — og:title, og:description and og:image — when the matching twitter:* tag is absent, so a complete set of og: tags plus twitter:card covers X. Image specs depend on the card type: a summary card uses a small ~1:1 image (at least ~144&times;144), while summary_large_image uses a large 1.91:1 image (recommended ~1200&times;628), in both cases an absolute https URL under 5 MB. A Twitter Card validator parses these tags, previews the resulting card by type and lints the tags and image against X&rsquo;s documented rules — useful because X removed its own official Card Validator around 2022.

SEO & Web

Related terms

twitter:cardsummary_large_imageOpen Graphog:imageX cardCard ValidatorSocial meta tagsLink preview

Frequently Asked Questions

No. X (Twitter) deprecated and removed its official Card Validator (the old cards-dev.twitter.com/validator) around 2022, so you can no longer preview your card on their site — the only way to see the live card now is to post or compose a draft on X.

X removed the preview from its official Card Validator around 2022 when Twitter rebranded to X; the old cards-dev.twitter.com/validator URL no longer renders a preview. The only way to see the real, live card today is to compose a post (or a draft) on X itself, or to share the link. This Twitter Card Validator fills the gap by parsing the twitter:* and og: tags you paste and rendering an X-style card preview by card type, plus a full lint — but it is explicit that it is an APPROXIMATION of how X renders, not X&rsquo;s actual renderer. It runs entirely in your browser, so unlike a server-side validator it never uploads or caches your page, which makes it safe for staging or unreleased pages; after you publish, confirm the real card by posting on X.

The only strictly required tag is twitter:card (use summary_large_image for a big-image preview). For the title, description and image, X falls back to your og:title, og:description and og:image when the twitter: equivalents are missing.

twitter:card is the only strictly required Twitter tag, and its value must be summary, summary_large_image, app or player — use summary_large_image for the big-image preview most sites want. twitter:title, twitter:description and twitter:image refine the card, and twitter:site / twitter:creator add the @handles of the site and author (they must start with @). Crucially, X falls back to your Open Graph tags: if twitter:title, twitter:description or twitter:image are absent, X reads og:title, og:description and og:image instead. So in practice a complete set of og: tags plus a single twitter:card tag produces a correct card. This validator lints the twitter:* tags AND shows every place where X will fall back to og:, and previews the card the way X renders it for the chosen card type.

Use an absolute https URL under 5 MB. For summary_large_image use a 1.91:1 image, ideally ~1200×628 (minimum 300×157); for a summary card use a ~1:1 image at least ~144×144. JPG, PNG, WEBP or GIF.

The image must be an ABSOLUTE https URL — X cannot fetch a relative or http path — and stay under 5 MB, in JPG, PNG, WEBP or GIF (avoid an animated GIF on the large card). The size depends on the card type: a summary_large_image card crops to a 1.91:1 ratio, so use about 1200&times;628 (the documented minimum is 300&times;157 and the maximum dimension is 4096&times;4096), while a summary card uses a square ~1:1 image of at least 144&times;144. This validator flags a missing, relative or http image, shows the exact spec table for the chosen card type, and confirms when the image is an absolute https URL — and because X falls back to og:image, it tells you when og:image is covering for a missing twitter:image.

No. Your HTML is parsed entirely in your browser with plain JavaScript — nothing is fetched, uploaded, logged or stored, and no page is crawled. That makes it safe for staging or unreleased pages.

The Twitter Card Validator is 100% client-side. The page source (or twitter:* form) you paste is parsed locally with the browser&rsquo;s DOMParser, and the preview and validation are built on your device — nothing is fetched, uploaded, logged or stored on a server, and no URL is crawled. That makes it safe for staging, unreleased or internal pages you do not want to expose, unlike online card validators that fetch your page and cache it on their servers. Because the browser cannot fetch most live URLs directly (cross-origin / CORS) and the tool uses no server proxy, you paste your source rather than a URL. It works offline once cached as a PWA, supports dark mode and mobile with a sticky action bar, and closing the tab discards everything you entered. It shares the same socialMetaEngine as the sibling Open Graph Checker, so both tools parse and validate from one source of truth.

Detailed Explanation

How It Works

What the Twitter Card Validator Parses, Previews and Validates

The Twitter Card Validator answers one practical question: when this page&rsquo;s link is shared on X (Twitter), what will the card look like, and are the twitter: tags correct? The user pastes the page&rsquo;s HTML source (View Source / Ctrl+U) — or picks the card type and fills a small form of the core tags (twitter:card, twitter:title, twitter:description, twitter:image, twitter:image:alt, twitter:site, twitter:creator) — and the shared engine socialMetaEngine.ts parses every twitter:* and og:* meta tag (plus the &lt;title&gt;, &lt;meta name="description"&gt; and &lt;link rel="canonical"&gt; used as fallbacks). From that it builds a live X-style CARD PREVIEW that changes by card TYPE: a summary card renders a small ~1:1 image on the left with the title, description and domain, while a summary_large_image card renders a large 1.91:1 image above the title and description (with a graceful placeholder when the URL can&rsquo;t load), applying the real twitter:* → og:* fallbacks X uses. It then VALIDATES the tags against X&rsquo;s documented rules and reports a clear pass / warn / fix for each, shows an image-spec table for the chosen card type, and lists a raw parsed-tags table. Everything runs in the browser with the DOMParser API — no upload, no crawl.

  • Parses every twitter:* and og:* tag (plus title, meta description and canonical fallbacks) with the browser DOMParser
  • Renders an X-style card preview that changes by type: summary (small ~1:1 image) vs summary_large_image (large 1.91:1 image)
  • Applies the real fallbacks X uses: twitter:title → og:title → <title>, twitter:description → og:description, twitter:image → og:image
  • Validates twitter:card, lengths, @handle format and image specs with a per-tag pass / warn / fix, plus an image-spec table by card type
  • All parsing, preview and validation is pure client-side JavaScript — no server call, no CDN, no upload, no crawl
Methodology

How the twitter: Tags Are Validated and the Card Is Modelled

The reusable engine socialMetaEngine.ts holds the rules as data and is shared with the sibling Open Graph Checker. parseSocialMeta(html) prefers DOMParser and falls back to a regex scan, returning twitter and og dictionaries (first occurrence wins, like a crawler), the flat tag list and the &lt;title&gt; / meta description / canonical fallbacks. validateTwitterCard(meta) checks that twitter:card is present and one of summary, summary_large_image, app or player (the only strictly required Twitter tag); checks twitter:title and twitter:description, noting where X falls back to og:title / og:description; checks twitter:image is an absolute https URL, escalating to an error when the card is summary_large_image but no twitter:image or og:image exists; and validates that twitter:site is an @handle — returning issues sorted error → warn → info → ok with pass/warn/fix counts. buildTwitterCardModel(meta) resolves the title, description, image, domain (host without protocol/www) and the effective cardType the way X does, applying twitter:* → og:* fallbacks, with hasRenderableImage true only for an absolute https URL; the page renders the card from that model with an onError image fallback and shows an image-spec table keyed to the card type (summary ~144×144 1:1; summary_large_image ~1200×628 1.91:1, under 5 MB, JPG/PNG/WEBP/GIF). Because the same engine powers the Open Graph Checker, both tools validate and preview from one well-typed source of truth.

  • socialMetaEngine.ts exports parseSocialMeta, validateTwitterCard and buildTwitterCardModel, shared with the Open Graph Checker
  • twitter:card is the only strictly required tag and must be summary, summary_large_image, app or player
  • Validation flags every twitter:* → og:* fallback and errors when summary_large_image has no twitter:image or og:image
  • Image checks by card type: summary ~144×144 (1:1); summary_large_image ~1200×628 (1.91:1), absolute https, under 5 MB
  • buildTwitterCardModel resolves title / description / image / domain and the effective card type the way X renders it
Limitations

X Removed Its Official Card Validator: This Previews and Lints, It Is Not X

The tool is explicit that it PREVIEWS and LINTS the tags you paste rather than being X&rsquo;s official renderer, for three honest reasons. First, X (TWITTER) REMOVED ITS OFFICIAL CARD VALIDATOR around 2022 — the old cards-dev.twitter.com/validator no longer renders a preview — so the only way to see the real, live card today is to compose a post or draft on X itself; this preview is an accurate APPROXIMATION, not X&rsquo;s pixel-exact renderer, and it renders differently across X&rsquo;s web, iOS and Android clients. Second, X FALLS BACK TO OPEN GRAPH: when twitter:title, twitter:description or twitter:image are absent, X reads og:title, og:description and og:image instead, and it CACHES the card aggressively, so after you edit your tags the old card can persist until you re-share. Third, YOUR BROWSER CANNOT FETCH MOST LIVE URLs directly because of the cross-origin (CORS) policy, and the tool deliberately uses NO server proxy so your page stays private; the optional &ldquo;try to fetch&rdquo; box only works for CORS-enabled or same-origin pages, so you paste your page source instead. The guidance is therefore to fix the tags here BEFORE publishing, use an absolute https image around 1200×628 (under 5 MB) for summary_large_image, and then confirm the live card by posting on X.

  • X removed its official Card Validator (cards-dev.twitter.com/validator) around 2022 — you can no longer preview cards on their site
  • This previews + lints as an approximation, not X’s renderer; X renders differently across web, iOS and Android
  • X falls back to og:title / og:description / og:image when twitter:* are missing, and caches the card — re-share to refresh
  • Browsers cannot fetch most live URLs (CORS) and the tool uses no server proxy, so paste your page source
  • Use an absolute https image, ~1200×628 (1.91:1) under 5 MB for summary_large_image; confirm the live card by posting on X
Privacy & Security

Why Validating Twitter Cards In-Browser Is a Privacy Win

Most online Twitter/X card validators work by FETCHING your URL on their server and caching the result, which exposes unreleased pages and stores a copy of your page on a third party. The Twitter Card Validator instead runs entirely on the user&rsquo;s device: the HTML (or twitter:* form) you paste is parsed with the browser&rsquo;s DOMParser and the preview and validation are computed locally; nothing is fetched, uploaded, logged or stored, and no page is ever crawled. That makes it safe to validate twitter: tags on STAGING, unreleased or internal pages before launch — exactly the pages you would not want a server-side validator to fetch and cache, and a real gap since X removed its own validator. It works offline once cached as a PWA, supports dark mode and mobile with a sticky Check / Copy bar, has exactly three ad slots, and adds NO new dependency — the parsing, validation and card modelling live in the small, reusable socialMetaEngine.ts, which the sibling Open Graph Checker also imports so both tools share one well-typed source of truth.

  • HTML and twitter: tags are parsed and previewed locally and never uploaded — no server, no CDN, no crawl
  • Safe for staging / unreleased pages, unlike online validators that fetch and cache your page server-side
  • Fills a real gap since X removed its official Card Validator (~2022); works offline once cached
  • No new dependency — parsing, validation and card modelling live in the reusable socialMetaEngine.ts, shared with the Open Graph Checker
  • Dark mode and mobile support with a sticky Check / Copy bar; exactly three ad slots
Twitter Card validation: in-browser (AnyTool) vs typical online card validators
CapabilityAnyToolTypical online tools
ProcessingParses your pasted HTML in your browserFetches & caches your URL server-side
Your pageNever uploaded, works offlineFetched and stored on a server
Staging pagesSafe — nothing leaves the browserExposed — server must reach the URL
PreviewX card by type (summary / summary_large_image) with image fallbackOften one generic card or none
Validationtwitter:card, lengths, @handles, image specs + og: fallback, pass / warn / fixBasic presence check or none
HonestyStates X removed its validator; previews as an approximationOften implies it is the live X card
Cost / signupFree, no signupOften gated or ad-heavy

AnyTool parses the page HTML (or twitter:* form) you paste entirely in your browser with the DOMParser API and uploads nothing, so it is safe for staging pages — unlike online validators that fetch and cache your URL on a server. It previews the X/Twitter card by card type (summary = small ~1:1 image; summary_large_image = large 1.91:1 image) and validates twitter:card, title/description lengths, the @handle format and image specs (absolute https, ~1200×628, under 5 MB), flagging where X falls back to og:. Honest caveat: X removed its official Card Validator (~2022), so this previews + lints as an approximation, not X’s renderer; X falls back to Open Graph, caches cards, and renders differently across clients; your browser can’t fetch most live URLs (CORS) and there is no server proxy, so paste your source. Comparison as of June 2026.