Twitter Card Validator Is Gone: Test X Cards in 2026

November 11, 2026 · 12 min read

Twitter Card Validator Is Gone: How to Test X Cards Now

The twitter card validator no longer shows previews. X removed that feature in August 2022 and now points you to the post composer instead. You can still test cards yourself. This guide lists the twitter: tags and image specs X reads, then shows how to check a card with the composer, curl and robots.txt.

What Happened to the Twitter Card Validator?

On August 2, 2022, X (then still called Twitter) announced on its developer forum that it had removed the preview from the Card Validator. The reason it gave: those previews didn't always match how cards looked across its apps. The same post sent developers to the composer, where a card renders as soon as you paste a URL with valid tags.

The old Twitter Card Validator page stayed up for a while for domain submissions and crawl logs. Today, cards-dev.x.com/validator and the older cards-dev.twitter.com/validator both send signed-out visitors to the X login page (we checked in November 2026). X's Cards documentation pages now redirect to the general docs.x.com overview too, so the specs below come from archived copies of X's developer site.

In practice, you test against the real crawler and the real composer. We think that's the better test anyway, because it's exactly what your readers will see.

What Is a Twitter Card?

A Twitter card is the preview block X attaches to a post that contains your link. It shows a title, a short description and an image, all pulled from meta tags in your page's head. When someone shares the URL, X's crawler fetches the page, reads those tags and builds the card.

X documents four card types:

  • summary: a small square thumbnail beside the title and description.
  • summary_large_image: a large, full-width image.
  • app: a card that points to an app store listing, built from its own twitter:app:* tags for iPhone, iPad and Google Play.
  • player: a card that plays video or audio in an iframe, set up with twitter:player, width and height tags.

This guide sticks to the two summary cards, since those are what blogs, docs and product pages use.

Card tags are separate from the images inside your content. A Markdown image such as ![Chart](https://example.com/chart.png) only appears in the page body, as our guide to adding images in Markdown explains. The card uses the image named in a meta tag, not one it finds in the article.

Twitter Card Types and Specs: Summary vs Summary Large Image

Twitter card size rules depend on the card type. The Twitter summary card wants a square image, the large image card a wide one, and both share the same file limits.

CardAspect ratioMinimum sizeDisplay
summary1:1144 x 144 pxSquare thumbnail, cropped to a square
summary_large_image2:1300 x 157 pxLarge, full-width image

These rules apply to both cards, per X's cards markup reference and its per-card pages:

  • The image can be at most 4096 x 4096 px and must be smaller than 5 MB.
  • JPG, PNG, WEBP and GIF are supported. Only the first frame of an animated GIF is used.
  • SVG isn't supported.
  • twitter:title allows 70 characters. The card pages say it's cut to two lines on iOS and Android and one line on the web.
  • twitter:description allows 200 characters. The same pages say the iOS and Android apps don't display it.
  • twitter:image:alt allows 420 characters.

Those display notes come from X's archived docs, so treat the composer as the source of truth for the current layout.

We prefer summary_large_image for articles and release notes, because the picture does most of the work in a busy feed. For an API reference page with no strong visual, summary keeps the card compact. Designing the image itself, from safe zones to cross-platform sizes, is covered in our Open Graph image guide.

How to Make a Twitter Card: The Meta Tags Your Website Needs

To make a Twitter card for website pages, add these tags inside the head element of each page, usually once in your site template. X's docs put every twitter: tag in a name attribute rather than property, though its parser also accepts property.

<meta name="twitter:card" content="summary_large_image" />
<meta name="twitter:site" content="@acmedocs" />
<meta name="twitter:creator" content="@janedev" />
<meta name="twitter:title" content="Acme CLI 3.0: Faster Installs and a New Config Format" />
<meta name="twitter:description" content="What changed in Acme CLI 3.0, how to upgrade from 2.x, and which flags were removed." />
<meta name="twitter:image" content="https://example.com/img/cli-3-release.png" />
<meta name="twitter:image:alt" content="Terminal window showing the acme install command finishing in 4 seconds" />

Here's what each line does:

  • twitter:card picks the layout, either summary or summary_large_image.
  • twitter:site is the @username of the site. The markup reference calls it required, while the per-card pages mark it optional, so treat it as recommended.
  • twitter:creator credits the author's account.
  • twitter:title and twitter:description are the card text, within the 70 and 200 character limits.
  • twitter:image is a full, absolute URL that the public internet can reach.
  • twitter:image:alt describes the image for people using screen readers.

You don't always need every line. When a twitter: tag is missing, X's markup reference says it reads the matching Open Graph tag:

X tagFalls back to
twitter:titleog:title
twitter:descriptionog:description
twitter:imageog:image
twitter:image:altog:image:alt
twitter:site and twitter:creatorNo fallback
twitter:cardNo tag, but a summary card may render when og:type, og:title and og:description exist

So a page with a full set of og: tags only needs twitter:card plus the two attribution tags. The og: tags themselves are covered in our Open Graph protocol guide.

Our meta tag generator writes these lines for you. Pick summary or summary_large_image, type your @site and @creator handles, and its output includes twitter:card, twitter:site, twitter:creator, twitter:title, twitter:description and twitter:image next to the OG tags. It runs in your browser and doesn't fetch your page or draw an X card, so add the alt line yourself and test with the steps below.

Twitter Card Example from Front Matter

Most static site generators build card tags from a post's front matter, so you rarely type them by hand. Here's a Docusaurus blog post using the title, description and image fields from the blog plugin's front matter reference:

---
title: Acme CLI 3.0 release notes
description: What changed in Acme CLI 3.0 and how to upgrade from 2.x.
image: https://example.com/img/cli-3-release.png
---

Docusaurus turns that into these tags, among others. It appends your site title to og:title, and its classic theme adds a site-wide twitter:card:

<meta name="twitter:card" content="summary_large_image" />
<meta property="og:title" content="Acme CLI 3.0 release notes | Acme" />
<meta property="og:description" content="What changed in Acme CLI 3.0 and how to upgrade from 2.x." />
<meta property="og:image" content="https://example.com/img/cli-3-release.png" />
<meta name="twitter:image" content="https://example.com/img/cli-3-release.png" />

Notice what's missing: twitter:title and twitter:description. X reads the og: values in their place, so this page still gets a full large image card. The YAML syntax is explained in our Markdown front matter guide, and the rest of the platform in Docusaurus Markdown.

Our editor's preview won't help here, because it ignores front matter and never builds a page head. Point the curl check below at the built page instead.

How to Test a Twitter Card Now That the Preview Is Gone

Without the Twitter Card Validator, you test a card with X's composer plus two quick server-side checks. None of them needs a third-party tool.

Step 1: paste the URL into the composer. Start a new post on x.com or in the X app and paste your link. X's 2022 announcement says the Twitter card preview renders automatically when the page has valid card tags, with no need to post. Discard the draft afterwards.

If the link will go out in a thread, our thread maker splits your text into numbered posts and counts each URL as 23 characters. It doesn't post to X or draw the card. To publish the parts yourself, follow our steps on how to make a Twitter thread.

Step 2: fetch the page as Twitterbot. X's crawler identifies itself as Twitterbot, with a version such as Twitterbot/1.0. Request your page with that user agent and filter for card tags:

curl -A "Twitterbot/1.0" -sL https://example.com/blog/cli-3 | grep -i "twitter:"

The -A flag sets the user agent, -s hides the progress meter and -L follows redirects. If the output is empty, your server isn't sending card tags to that user agent, whatever your browser shows. Swap the pattern for og: to check the fallback tags too. For Facebook and LinkedIn previews, our guide on how to check meta tags covers their own debuggers.

Step 3: confirm robots.txt lets Twitterbot in. X's troubleshooting guide gives this exception block:

User-agent: Twitterbot
Disallow:

An empty Disallow line means nothing is off limits for that crawler. The guide also says Twitterbot follows Google's robots.txt specification, where the most specific matching group wins, so this block beats a general User-agent: * rule.

Third-party sites that call themselves a Twitter card validator still exist, but each draws its own approximation of a card. That mismatch is why X dropped its own preview. This workflow has limits too: the composer needs an X account, and Twitterbot can't crawl a staging site that sits behind a login.

Why Is My Twitter Card Not Showing?

When the composer shows a bare link, work through these causes from X's troubleshooting guide:

  1. Twitterbot is blocked. A robots.txt rule, a deny line in an Apache .htaccess file or your host's firewall can stop it. Settings on a hosted CMS can block it too.
  2. The HTML response is too large. X's crawler has a 2 MB limit for page responses, so heavy inline scripts or data can push a page over.
  3. The image breaks a rule. It's 5 MB or more, smaller than 144 x 144 pixels, an SVG, or not publicly reachable. Images on a private staging server are a common trap.
  4. JavaScript adds the tags. X's docs don't say the crawler runs scripts. If a client-side app injects the meta tags after load, render them on the server and confirm with the curl test.
  5. TLS is misconfigured. The guide says the crawler requires TLS 1.1 or newer and suggests checking the rest of your SSL setup.
  6. No card type is set. Without twitter:card, X may fall back to a summary card, but only when og:type, og:title and og:description are all present.

Refreshing a Stale X Card: Cache, Query Strings and Image URLs

X caches card data. Its troubleshooting guide says the crawler re-indexes a page's card tags roughly every seven days, so a fixed tag can keep showing the old card for about a week.

To see a change sooner, share a URL X hasn't cached yet. A harmless query parameter such as ?v=2 makes the same page a new URL. The guide pairs this with fresh bit.ly links built from placeholder parameters like ?x=test1, and X's 2022 announcement warns that new metadata can still take a while to show.

Images are cached separately, by their own URL. If you overwrite the image file but keep its name, X can keep the old picture even after the text updates. Rename the file, or add a parameter to the image URL:

<meta name="twitter:image" content="https://example.com/img/cli-3-release.png?v=2" />

Quick Answers on X Cards and the Old Validator

Since the twitter card validator lost its preview, the reliable test is the one your readers see: the X composer, backed by a Twitterbot curl and a robots.txt check. Set the tags once in your template or front matter and every page inherits them. Draft the post itself in our Markdown editor, which is free and needs no account, then let your site's template add the card tags when it builds the page.