How to Extract OpenGraph & Social Card Meta Tags in 2026

When you paste a link into Slack, LinkedIn, Facebook or X, the rich preview card that appears is built from meta tags in the page’s HTML — og:title, og:image, twitter:card and friends. When that card is broken or missing, it’s almost always one absent or malformed tag, and there’s no easy way to check hundreds of URLs at once. Facebook’s debugger does one URL at a time; browser dev tools mean manual inspection. This guide covers how social-preview meta tags work and how to bulk-extract every OpenGraph, Twitter Card and structured-data tag across a list of URLs so you can audit link previews at scale.

What’s worth extracting

The actor returns one row per URL with 18 fields covering the full social and SEO meta surface. Grouped by protocol:

• OpenGraph — ogTitle, ogDescription, ogImage, ogUrl, ogType, ogSiteName, ogLocale. These are what Facebook, LinkedIn and most platforms read.
• Twitter Card — twitterCard (the card type, e.g. summary_large_image), twitterTitle, twitterDescription, twitterImage, twitterSite.
• Basic SEO — the HTML title tag, the meta description, canonicalUrl and favicon.
• Structured data — jsonLdTypes, the schema.org @type values found in JSON-LD blocks (Article, Product, Organization…).
• Extras — themeColor, apple-touch-icon, and a complete allMetaTags field: a JSON dump of every meta tag the page exposed, for custom analysis.

Plus a scrapedAt timestamp. The allMetaTags dump is the escape hatch — even if a field you care about isn’t broken out into its own column, it’s in there, so you’re never blind to a tag the page defined.

How the extraction actually works

The actor fetches each page’s server-rendered HTML over pure HTTP and parses the meta tags out of it — no browser, no login, no API key. This is the same markup any social platform’s crawler reads when it builds a preview, so what you extract is exactly what those platforms see.

The input is a list of URLs plus toggles for which tag groups to pull. A basic audit run:

{
  "startUrls": [
    { "url": "https://apify.com" },
    { "url": "https://github.com" },
    { "url": "https://openai.com" }
  ],
  "proxyConfiguration": { "useApifyProxy": true }
}

Each URL is passed as an object with a url key. The four extraction toggles — includeOG, includeTwitter, includeStructured and includeBasic — all default to true, but you can switch groups off to keep runs lean. For a competitor analysis where you only care about the social card, drop the SEO and structured-data extraction:

{
  "startUrls": [
    { "url": "https://competitor.com/blog/post-a" },
    { "url": "https://competitor.com/blog/post-b" }
  ],
  "includeStructured": false,
  "includeBasic": false,
  "proxyConfiguration": { "useApifyProxy": true }
}

For a post-migration QA sweep, raise the maxUrls cap and feed the whole list:

{
  "startUrls": [
    { "url": "https://example.com/page-1" },
    { "url": "https://example.com/page-2" }
  ],
  "maxUrls": 1000,
  "proxyConfiguration": { "useApifyProxy": true }
}

maxUrls (default 100, ceiling 1,000) is the per-run limit. Because everything runs over plain HTTP with no browser, inspection is fast even across hundreds of pages.

▶ Open the OpenGraph & Social Card Inspector on Apify — paste a URL list, get every OpenGraph, Twitter Card, JSON-LD and SEO tag as one clean row per URL. No browser, no login, no API key. Export to JSON, CSV, Excel or HTML.

The access reality

This is a lightweight HTTP tool, so the friction is small — but there are two real constraints worth understanding.

• It reads server-rendered HTML, so it does not run JavaScript. For JavaScript SPAs that inject meta tags client-side, those tags may not be present in the raw HTML and won’t appear in the output. This mirrors reality: many social crawlers also don’t execute JavaScript, so a tag that only exists after client-side render is often broken for previews anyway. If you need to see the actual rendered visual, capture a screenshot instead.
• Some sites block datacenter IPs. The actor supports Apify Proxy for exactly this — flip proxyConfiguration to use Apify Proxy (on by default) so pages that reject datacenter requests still respond.
• The 1,000-URL ceiling is per run. For larger inventories, split the list across runs or schedule them.
• It extracts, it doesn’t validate images. The actor pulls the ogImage and twitterImage URLs but doesn’t check whether they return 200. To catch broken og:image links, feed those URLs into a URL status checker as a second step.

Example output

One trimmed row per URL:

{
  "url": "https://github.com",
  "ogTitle": "GitHub · Build and ship software on a single, collaborative platform",
  "ogImage": "https://github.githubassets.com/assets/campaign-social.png",
  "ogType": "website",
  "ogSiteName": "GitHub",
  "twitterCard": "summary_large_image",
  "twitterImage": "https://github.githubassets.com/assets/campaign-social.png",
  "title": "GitHub: Let's build from here",
  "canonicalUrl": "https://github.com/",
  "jsonLdTypes": ["Organization", "WebSite"],
  "favicon": "https://github.githubassets.com/favicons/favicon.svg",
  "themeColor": "#1e2327",
  "scrapedAt": "2026-07-06T12:00:00.000Z"
}

The full row also carries ogDescription, ogUrl, ogLocale, the Twitter title/description, the meta description, and the complete allMetaTags JSON dump.

Typical use cases

• SEO audits at scale — paste hundreds of client URLs and get a spreadsheet showing exactly which pages have complete OpenGraph markup, which have a broken og:image, and which are missing Twitter Card tags entirely.
• Social-media debugging — figure out why a link shows no rich preview on Slack, WhatsApp or LinkedIn: run the URL, view every extracted tag in one place, and spot the missing or malformed one.
• Competitive social-card analysis — study a competitor’s og:title patterns, og:image usage and preferred twitter:card types across their blog and landing pages.
• Content inventory & migration QA — after a site migration, verify that every page’s social meta tags and structured data survived the move.
• Automated link-preview generation — build a tool that accepts a URL and returns a rich preview card (title, description, image) from the extracted tags.
• Broken-image triage — extract the ogImage/twitterImage URLs, then run them through a status checker to catch 404s before they embarrass you in a shared link.

Build-it-yourself vs. managed

A meta-tag parser is genuinely simple to start — fetch HTML, parse a few tags. The work that accumulates:

• Complete tag coverage. OpenGraph, Twitter Card, JSON-LD, canonical, favicon, apple-touch-icon and theme-color are all parsed differently; getting all of them right, plus a full allMetaTags dump, is more than a quick regex.
• JSON-LD extraction. Pulling @type values out of application/ld+json script blocks means parsing embedded JSON, not just reading attributes.
• Bulk orchestration. Running 1,000 URLs concurrently, handling timeouts and per-site failures without one bad URL killing the run.
• Proxy handling for sites that block datacenter IPs.
• Export plumbing into CSV/JSON/spreadsheet form.

None of it is hard, but it adds up to a small project plus maintenance. The managed actor already covers the full tag surface and runs on pay-per-result pricing — a fraction of a cent per URL inspected — so auditing a few hundred pages costs pennies, with no monthly subscription.

Common pitfalls

Specifics that will trip up a social-card audit:

• Client-side-injected tags won’t show up. If a page sets its OpenGraph tags with JavaScript after load, the raw HTML won’t contain them — which is exactly why the preview is often broken on social platforms too. Don’t assume the actor is wrong; the tag genuinely isn’t in the server HTML.
• og:title and the HTML title are different fields on purpose. og:title is what Facebook/LinkedIn display; the title tag is what Google shows in search results. They’re frequently different, so the actor returns both — track both.
• Extracting an image URL is not the same as it working. A present ogImage can still 404. Pipe the image URLs through a status checker to confirm.
• jsonLdTypes is an array. A single page can declare multiple schema.org types (e.g. Organization and WebSite). Handle it as a list, not a single value.
• allMetaTags is a JSON string. Parse it before iterating if you need the raw tag map — it’s stored as a serialized dump.
• The 1,000-URL cap is per run. For a full-site inventory, expand a sitemap into a URL list first, then chunk it across runs.

Wrapping up

Auditing social cards one URL at a time is fine for a single broken link and hopeless for a whole site. If you only need to debug one page, a browser dev-tools inspection works. If you need to check hundreds of URLs for complete OpenGraph, Twitter Card and JSON-LD markup — and export the results to a spreadsheet — the managed actor does it in one run.

▶ Run the OpenGraph & Social Card Inspector on Apify — one run returns every OpenGraph, Twitter Card, JSON-LD and SEO tag for up to 1,000 URLs, one clean row each. No browser, no login, no API key. Export to JSON, CSV, Excel or HTML. Start on Apify’s free monthly credit.