Does the Twitter Card Validator still work?

No. X retired the standalone Card Validator. The old URLs, cards-dev.twitter.com/validator and cards-dev.x.com/validator, no longer load a working tool, and there is no direct replacement inside X. To check a card now you draft the tweet and read the composer preview, inspect the page's served twitter: and og: meta tags, or use a third-party Open Graph debugger, since X reads the same tags.

How do I validate a Twitter card in 2026?

Paste the URL into the X composer (on a draft or a test account) and look at the preview it renders. That is ground truth, because it is X reading your live tags. To confirm the tags before posting, run view-source or curl on the URL and check that twitter:card and og:image are present in the raw HTML. A general Open Graph preview tool works too, since X falls back to og: tags.

Where did the Twitter Card Validator go?

It was removed during X's platform changes. The validator lived at cards-dev.twitter.com/validator and let you paste a URL to preview the card and see any tag errors. Those pages still rank in search but no longer function. X did not ship an in-app replacement, so validation now means drafting the tweet or inspecting the tags directly.

How do I test a Twitter card without posting a tweet?

Inspect the tags instead of posting. Run curl on the live URL, or open view-source, and confirm the head contains twitter:card set to summary_large_image plus an absolute https og:image. A third-party Open Graph debugger fetches those tags and renders a preview without touching X. The only fully accurate check is X's own composer, so use a draft or a throwaway account if you need certainty.

Why is my X card not showing after I fixed the tags?

Almost always caching. X stored the metadata the first time the URL was shared and reuses it. Append a unique query string such as ?v=2 when you re-post and X treats it as a new link with no cache entry. If it still fails, the image is likely relative, behind auth, below the 1.91 to 1 ratio, or injected by JavaScript that X never runs.

Back to blog

OG images

Twitter Card Validator: How to Test Your X Link Preview (the Validator Is Gone)

July 2, 2026 · 8 min read · Grabbit Team

X used to have a dedicated Twitter Card Validator: paste a URL into cards-dev.twitter.com/validator, and it previewed the card and flagged any missing tags. That tool is gone. The URL no longer loads a working validator, and X never shipped an in-app replacement. If you are searching for the Twitter Card Validator to check how a link will unfurl on X, this is how you do it now.

The short answer

There is no working Twitter Card Validator anymore. To validate an X card in 2026, use one of these three methods:

Draft the tweet. Paste the URL into the X composer and read the preview. This is the only fully accurate check, because it is X reading your live tags.
Inspect the served tags. curl the URL or use view-source and confirm twitter:card and og:image are in the raw HTML, before any JavaScript runs.
Use a third-party Open Graph debugger. X falls back to og: tags, so a general Open Graph preview tool shows you the same card.

The rest of this guide covers each method, how to read the tags correctly, and why a card still breaks after the tags look right.

What happened to cards-dev.twitter.com/validator

The old validator lived at cards-dev.twitter.com/validator (later cards-dev.x.com/validator). You pasted a URL, and it fetched the page, rendered the card exactly as the timeline would, and listed errors like a missing twitter:card tag or an unreachable image. It was the fastest way to catch a broken preview before posting.

During X's platform changes the tool was retired. Those URLs still rank at the top of search results, which is why so many people land on a dead page. There is no equivalent inside X today. So "validating a card" no longer means one tool; it means checking the same underlying signals the validator used to check for you: the twitter: and Open Graph meta tags in your page's HTML.

How X actually builds a card

Understanding what X reads makes every validation method obvious. X does not screenshot your page or infer its content. When a URL is posted, X fetches the raw HTML and reads two families of meta tags from the <head>: the twitter: tags, and the Open Graph og: tags as a fallback.

<meta name="twitter:card" content="summary_large_image" />
<meta property="og:title" content="Your Page Title" />
<meta property="og:description" content="A one-line summary of the page." />
<meta property="og:image" content="https://yourdomain.com/og.png" />

The only tag with no Open Graph equivalent is twitter:card; it picks the layout, and summary_large_image gives you the full-width 1.91 to 1 banner. For title, description, and image, X falls back to the og: tags, so setting twitter:card plus the four og: tags is enough. That is also why the same tags that fix a LinkedIn link preview fix the X card. For the exact image dimensions, see Twitter card image size.

Two things trip people up, and both are things the old validator would have caught:

X reads raw HTML, not the rendered page. It does not run your JavaScript. Tags injected client-side are invisible to X.
og:image must be absolute and public. A relative /og.png will not resolve, and an image behind auth or a redirect renders as no image.

Method 1: draft the tweet (ground truth)

Open the X composer and paste your URL. Wait a second for the card to unfurl and look at what renders. This is the most accurate check available because it is X itself fetching and reading your live tags, exactly as it will when the post goes out.

If you do not want a draft sitting in your account or you are testing an unpublished change, use a throwaway or test account. You do not have to publish; the composer preview appears before you post. The downside is that this is the only method that requires an X account, and X caches aggressively, which is the single most common reason a corrected card still looks wrong (covered below).

Method 2: inspect the served tags

You can confirm the tags are correct without touching X at all. Because X reads the raw HTML, curl gives you exactly what X sees:

curl -s https://yourdomain.com/your-page | grep -Eo '<meta[^>]+(twitter:|og:)[^>]+>'

You are looking for twitter:card set to summary_large_image and an og:image (or twitter:image) pointing at an absolute https URL. If a tag is missing from this output, it is missing as far as X is concerned, even if it appears in your browser's inspector after JavaScript runs. This is the fastest pre-publish check and it catches the most frequent failure, which is a single-page app that injects meta tags after load.

Method 3: a third-party Open Graph debugger

Several free tools fetch a URL and render the card the way X would: X card preview tools and general Open Graph debuggers both work, because X reads the same og: tags every other platform reads. They are convenient for a quick visual check and require no X account. The caveat is that they render their own interpretation of the tags rather than X's, so treat them as a strong preview, not the final word. For validating the image itself before it ships, our OG image checker walks through previewing the preview.

Make the card image a real render of your page

Once the tags validate, the remaining question is what the image should be. A generic logo is a wasted card. For a marketing page, a docs page, or a launch, the most compelling preview is usually a clean render of the page itself, sized to the card's 1200 by 628 frame.

You can produce that with a screenshot API: point it at the URL, get back a hosted image at the exact size, and use that as your og:image / twitter:image.

curl https://api.grabbit.live/v1/grabs \
  -H "Authorization: Bearer sk_live_..." \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://yourdomain.com/og",
    "width": 1200,
    "height": 628,
    "format": "png",
    "delay_ms": 500
  }'

The response includes a hosted image_url:

{
  "id": "grb_01jx...",
  "status": "done",
  "image_url": "https://cdn.grabbit.live/grabs/grb_01jx....png",
  "width": 1200,
  "height": 628,
  "format": "png",
  "bytes": 68820,
  "execution_ms": 1180
}

width accepts 320 to 1920 and height 240 to 1080, so a 1200 by 628 card is in range. delay_ms (0 to 10000) gives web fonts or client-rendered content a moment to settle before capture. Drop the returned image_url into your tags:

<meta property="og:image" content="https://cdn.grabbit.live/grabs/grb_01jx....png" />
<meta name="twitter:image" content="https://cdn.grabbit.live/grabs/grb_01jx....png" />

Capture once per unique page and cache the image_url alongside the page record instead of rendering on every request. A common pattern is a dedicated /og route built from your normal components, captured at 1200 by 628 and reused everywhere. The same template-and-cache approach appears in how to generate dynamic OG images from any URL.

The card still is not showing after the tags check out

If all three methods say the tags are correct but the live post still shows no image or a small thumbnail, work through these in order:

Caching. X stored the metadata the first time the URL was shared. Append a unique query string such as ?v=2 when you re-post so X treats it as a fresh link.
twitter:card is missing. Without summary_large_image, X defaults to the small summary card, so even a correct image appears as a thumbnail.
The image is relative, behind auth, or behind a redirect. X renders no image in all three cases. Test the raw image URL in a private browser window.
The image is the wrong shape. Below the 1.91 to 1 ratio, X may fall back to the small card. Use 1200 by 628.
Tags are set by JavaScript. X does not run scripts. Server-render the meta tags so they are in the HTML curl returns.

The short version

X retired its Twitter Card Validator, so there is no single tool to paste a URL into anymore. Validate a card by drafting the tweet (ground truth), inspecting the served twitter: and og: tags with curl, or using a third-party Open Graph debugger. If a corrected card still fails, it is almost always caching, so re-post with a ?v=2 query string. And if you want the card image to be a real render of the page instead of a static logo, a screenshot API turns the live URL into the hosted image your tags point at. For the exact dimensions, see Twitter card image size.

FAQ

Does the Twitter Card Validator still work?: No. X retired the standalone Card Validator. The old URLs, cards-dev.twitter.com/validator and cards-dev.x.com/validator, no longer load a working tool, and there is no direct replacement inside X. To check a card now you draft the tweet and read the composer preview, inspect the page's served twitter: and og: meta tags, or use a third-party Open Graph debugger, since X reads the same tags.
How do I validate a Twitter card in 2026?: Paste the URL into the X composer (on a draft or a test account) and look at the preview it renders. That is ground truth, because it is X reading your live tags. To confirm the tags before posting, run view-source or curl on the URL and check that twitter:card and og:image are present in the raw HTML. A general Open Graph preview tool works too, since X falls back to og: tags.
Where did the Twitter Card Validator go?: It was removed during X's platform changes. The validator lived at cards-dev.twitter.com/validator and let you paste a URL to preview the card and see any tag errors. Those pages still rank in search but no longer function. X did not ship an in-app replacement, so validation now means drafting the tweet or inspecting the tags directly.
How do I test a Twitter card without posting a tweet?: Inspect the tags instead of posting. Run curl on the live URL, or open view-source, and confirm the head contains twitter:card set to summary_large_image plus an absolute https og:image. A third-party Open Graph debugger fetches those tags and renders a preview without touching X. The only fully accurate check is X's own composer, so use a draft or a throwaway account if you need certainty.
Why is my X card not showing after I fixed the tags?: Almost always caching. X stored the metadata the first time the URL was shared and reuses it. Append a unique query string such as ?v=2 when you re-post and X treats it as a new link with no cache entry. If it still fails, the image is likely relative, behind auth, below the 1.91 to 1 ratio, or injected by JavaScript that X never runs.

Capture any website with one API call

Get a free test key and capture your first screenshot in two minutes.

Get your free test key Learn more

Written by

Grabbit Team

Screenshots as a service

The team behind Grabbit, the screenshot API for developers and AI agents. We write about web capture, rendering, and automating screenshots at scale.

Keep reading

OG images

Twitter Card Image Size: The Right Dimensions for X Link Previews

The Twitter (X) card image size that renders a large preview is 1200 by 628 pixels at a 1.91 to 1 ratio. Here is how to set twitter:card and og:image, validate the card, and make the image a real screenshot of your page.

Jun 25, 2026 · 7 min read

OG images

How to Fix LinkedIn Link Previews (Open Graph for LinkedIn)

Why your LinkedIn link shows up bare or with the wrong image, and how to fix it: add the right Open Graph tags, point og:image at a real 1200x627 render, and force LinkedIn to re-scrape with Post Inspector.

Jun 24, 2026 · 7 min read

OG images

How to Test and Preview Your OG Image Before Publishing

Preview your OG image before you publish using platform debuggers and a screenshot API. Test how a link unfurls on X, Facebook, LinkedIn, Slack, and from localhost.

Jun 14, 2026 · 5 min read