# Meta Tags & Open Graph Checker: Bulk SEO + Schema (`datawright-labs/meta-tags-checker`) Actor

Bulk meta tags checker: title and meta description lengths, canonical, noindex, hreflang, Open Graph and Twitter card tags (og:image tested), JSON-LD schema.org types with missing rich-result fields, and SEO problems per URL. Callable by AI agents via MCP. $1 per 1,000 URLs.

- **URL**: https://apify.com/datawright-labs/meta-tags-checker.md
- **Developed by:** [Datawright Labs](https://apify.com/datawright-labs) (community)
- **Categories:** SEO tools, Developer tools
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 url checkeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

**For AI agents:** Use when asked to check or extract meta tags, the title and meta description, canonical, robots/noindex, hreflang, Open Graph or Twitter card tags, social preview images, or JSON-LD / schema.org structured data for one or many URLs. Call with `urls` (required), optional `outputFilter` (`all`, `problems`, `issues`), `checkOgImage` (default true), `includeRawJsonLd` and `userAgent` (`browser`, `googlebot`, `facebook`, `mobile`). Returns one row per URL: `title`, `titleLength`, `metaDescription`, `metaDescriptionLength`, `canonical`, `indexable`, `h1`, `lang`, `openGraph`, `ogImageCheck`, `twitter`, `hreflang`, `schemaTypes`, `schemaItems` (with missing rich-result properties), `problems`, `warnings`. Cost: $0.001 per URL ($1 per 1,000); unreachable, blocked and 4xx/5xx pages and invalid inputs free.

**For people:** Tell your AI agent "check the meta tags and social previews of every page in our sitemap and list the pages missing a description or og:image" and it hands the list to this tool, then reads back the fixes. No pasting URLs into an online meta tag checker one at a time, and 1,000 pages cost $1.

**Bulk meta tags checker and Open Graph checker for hundreds or thousands of URLs in one run.** Paste a list of pages and this SEO meta tag analyzer loads each one (following redirects) and extracts everything search engines and social networks read: the **title tag** and **meta description** with their lengths, **canonical URL**, **meta robots / X-Robots-Tag (noindex, nofollow)**, **hreflang** alternates, **H1**, **html lang**, **viewport**, **favicon**, every **Open Graph** tag (og:title, og:description, og:image, og:url, og:type, og:site_name) and **Twitter card** tag, and the **JSON-LD schema.org structured data** types on the page. It tests that the **og:image actually loads**, flags **schema.org items missing the properties Google needs for rich results**, and gives each page a plain-English **problems** and **warnings** list. A **SUMMARY** record lists **duplicate titles and meta descriptions** across the run.

No proxies, no API keys and no browser: results export to **CSV, Excel, JSON or Google Sheets**, or run on a **schedule** to catch meta tag regressions after every release.

### What does this meta tags checker do?

- 🏷️ **SEO meta tags**: title and meta description (with character counts and length warnings), canonical (self or pointing elsewhere, conflicting canonicals), meta robots and X-Robots-Tag (noindex / nofollow), H1 count, lang, charset, viewport, favicon, keywords, author, generator.
- 🖼️ **Open Graph and Twitter card checker**: every og: and twitter: tag, with the **og:image requested** to confirm it returns an image (status, content type, size). Missing og:title / og:image and broken preview images are flagged, so links look right when shared on Facebook, LinkedIn, X, Slack, WhatsApp or iMessage.
- 🧩 **Structured data (schema.org) extractor**: JSON-LD types (Product, Article, Organization, BreadcrumbList, FAQPage, Recipe, Event, JobPosting, LocalBusiness, VideoObject...), microdata and RDFa types, invalid JSON-LD blocks, and items missing the properties Google requires for rich results. Turn on **Include raw JSON-LD** to get the full parsed structured data.
- 🌍 **Hreflang checker**: every alternate language URL, invalid language codes, duplicates, missing self-reference and missing x-default.
- 🤖 **Desktop, Googlebot, Facebook crawler or iPhone user agent**, to see what each crawler gets.
- 🧹 **Bulk-friendly**: full URLs or bare domains, de-duplicated, up to 50 pages in parallel (at most 4 per host). Bot-challenge pages and 4xx/5xx errors are reported free.

### Use cases

- **SEO audits**: find pages with missing, too long or duplicate titles and meta descriptions, noindex by mistake, or canonicals pointing elsewhere.
- **Social sharing QA**: make sure every blog post, product and landing page has og:title, og:image and a Twitter card before a campaign.
- **Rich results**: list which pages carry Product, Article, FAQ or Breadcrumb schema and which required properties are missing.
- **Site migrations and releases**: re-run after a deploy and compare titles, canonicals and robots tags.
- **Competitor research and link previews**: extract titles, descriptions, Open Graph images and schema data from any list of URLs.
- **Scheduled monitoring**: run weekly with **Only URLs with problems** and get an email, Slack message or webhook when something breaks.

### How to use it

1. Paste URLs into **URLs**, one per line (or get every page of a site with the Sitemap URL Extractor first).
2. Optionally choose **Which URLs to save**, the **User agent**, and whether to **Include raw JSON-LD**.
3. Click **Start**, then open the **Overview** or **Social previews** table, or export the results.

#### Input example

```json
{
  "urls": [
    "https://apify.com",
    "https://github.com/apify/crawlee",
    "https://www.bbc.com/news"
  ],
  "checkOgImage": true,
  "outputFilter": "all"
}
```

### Output example

```json
{
  "url": "https://apify.com/",
  "status": "ok",
  "finalUrl": "https://apify.com/",
  "statusCode": 200,
  "title": "Apify: Marketplace of ready-to-run tools for AI",
  "titleLength": 47,
  "metaDescription": "Cloud platform for web scraping, browser automation, AI agents, and data for AI...",
  "metaDescriptionLength": 151,
  "canonical": "https://apify.com/",
  "canonicalIsSelf": true,
  "metaRobots": null,
  "indexable": true,
  "h1": "Get real-time web data for your AI",
  "h1Count": 1,
  "lang": "en",
  "openGraph": { "title": "Apify: Marketplace of ready-to-run tools for AI", "image": "https://apify.com/og-image/home", "type": "website", "url": "https://apify.com/", "siteName": "Apify" },
  "ogImageCheck": { "statusCode": 200, "contentType": "image/png", "bytes": null, "ok": true },
  "twitter": { "card": "summary_large_image", "site": "@apify" },
  "hreflang": [],
  "schemaTypes": ["Organization", "WebSite", "SoftwareApplication", "Offer"],
  "schemaItems": [{ "type": "Organization", "name": "Apify", "missing": [] }],
  "ok": true,
  "problems": [],
  "warnings": [],
  "checkedAt": "2026-10-25T20:30:00.000Z"
}
```

Pages that can't be loaded (DNS failure, timeout, refused), bot-challenge pages and pages returning HTTP 4xx/5xx come back with `status: "error"`, `"blocked"` or `"http-error"` and are **free**. The **SUMMARY** record in the key-value store has the counts plus duplicate titles and meta descriptions.

### How much does a meta tag check cost?

You pay **$0.001 per page checked** ($1 per 1,000 URLs), including the og:image test. **Unreachable, blocked and 4xx/5xx pages and invalid inputs are free**, and URLs skipped by **Which URLs to save** are **free** too. No start fee.

| Job | Pages | Cost |
|---|---|---|
| Audit a 300-page website | 300 | **$0.30** |
| Weekly meta tag monitor for 1,000 pages | ~4,000/month | **~$4/month** |
| Open Graph and schema data for 20,000 URLs | 20,000 | **$20** |

- Apify's **free plan includes $5 of monthly credit**, enough for about **5,000 pages a month**.
- Paid Apify plans get automatic discounts: **Silver -10%**, **Gold and above -20%**.
- Set **Maximum cost per run** to cap spend; the Actor stops cleanly at the limit.

### Bulk meta tags checker vs. the alternatives

| | This Actor | Online meta tag / OG preview checkers | Browser extensions | SEO crawler licenses |
|---|---|---|---|---|
| Thousands of URLs per run | ✅ | ❌ one at a time | ❌ one tab at a time | ✅ |
| Title, description, canonical, robots, hreflang | ✅ | partly | ✅ | ✅ |
| Open Graph + Twitter card with og:image test | ✅ | ✅ | partly | partly |
| JSON-LD schema types + missing rich-result fields | ✅ | ❌ | partly | ✅ |
| CSV / Excel / JSON / Sheets export, schedules, webhooks | ✅ | ❌ | ❌ | varies |
| Callable by AI agents (MCP) | ✅ | ❌ | ❌ | ❌ |
| Cost model | $1 per 1,000 pages, no subscription | free, manual | free, manual | yearly license |

### Use it as an API (Python, JavaScript, cURL)

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("datawright-labs/meta-tags-checker").call(run_input={"urls": ["https://apify.com", "https://example.com"]})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["input"], item.get("title"), item.get("openGraph", {}).get("image"), item.get("problems"))
```

#### JavaScript / Node.js

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('datawright-labs/meta-tags-checker').call({ urls: ['https://apify.com'] });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/datawright-labs~meta-tags-checker/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" -d '{"urls":["https://apify.com"],"outputFilter":"all"}'
```

### Use it from your AI agent (MCP)

Your AI assistant or agent can run this Actor as a tool through [Apify's MCP server](https://docs.apify.com/platform/integrations/mcp), so it can audit meta tags on its own while you chat. Add this server to any MCP client that supports remote (Streamable HTTP) servers:

```json
{
  "mcpServers": {
    "datawright-meta-tags-checker": {
      "url": "https://mcp.apify.com?tools=datawright-labs/meta-tags-checker"
    }
  }
}
```

On first use your browser opens to sign in to Apify (OAuth). If your client can't do OAuth, add `"headers": { "Authorization": "Bearer <YOUR_APIFY_TOKEN>" }` instead. The tool shows up as `datawright-labs--meta-tags-checker`, with the same input fields as above, and the agent reads the results with `get-dataset-items`. Then just ask, for example:

> Check the meta tags of these 50 blog posts and list the ones with a missing og:image, a title over 60 characters or no Article schema.

Want several Datawright tools at once? Comma-separate them: `https://mcp.apify.com?tools=datawright-labs/meta-tags-checker,datawright-labs/sitemap-url-extractor`. Runs are billed per result, exactly like normal runs.

### FAQ

#### How do I check the meta tags of a website?

Paste its URLs and run. Each row has the title, meta description, canonical, robots, Open Graph, Twitter and schema data of one page, plus a `problems` list of what to fix. To check a whole site, get its URLs from the Sitemap URL Extractor first.

#### How long should a title tag and meta description be?

Google typically shows about 50-60 characters of a title and 150-160 characters of a description. This checker warns above 60 / 160 and below 15 / 50 characters, and lists duplicates across your pages in the SUMMARY record.

#### How do I check Open Graph tags and the og:image?

Every og: tag is extracted, and with **Check that og:image loads** on (default) the image URL is requested to confirm it returns an image. Use the **Facebook link preview bot** user agent to see exactly what Facebook's crawler gets.

#### Can it extract JSON-LD structured data?

Yes. `schemaTypes` lists the schema.org types found, `schemaItems` lists each item and any properties missing for Google rich results, and **Include raw JSON-LD** adds the full parsed JSON-LD so you can extract product prices, article dates, ratings or organization details.

#### Does it render JavaScript?

No, it reads the HTML the server sends, which is what most social crawlers (Facebook, LinkedIn, X, Slack) see too. Meta tags injected only by client-side JavaScript show up as missing, which is worth fixing anyway.

#### Does it check hreflang?

Yes: every alternate URL with its language code, plus invalid codes, duplicates, a missing self-reference and a missing x-default. Hreflang return links on the other pages aren't fetched.

### More tools from Datawright Labs

- [Sitemap URL Extractor](https://apify.com/datawright-labs/sitemap-url-extractor): get every URL of a site from its sitemaps, then check their meta tags here.
- [Broken Link Checker](https://apify.com/datawright-labs/broken-link-checker): crawl a whole site and find broken links, images and redirects, with the page and anchor text of each.
- [Redirect Checker](https://apify.com/datawright-labs/redirect-checker): bulk redirect chains (301, 302, meta refresh), final URL and status, loops and old-to-new migration checks.
- [Security Headers Checker](https://apify.com/datawright-labs/security-headers-checker): bulk HSTS, CSP, X-Frame-Options and HTTPS redirect checks with an A-F grade.
- [Bulk PageSpeed & Core Web Vitals Checker](https://apify.com/datawright-labs/pagespeed-auditor): audit PageSpeed / Lighthouse scores for many URLs.
- [Website Screenshot API](https://apify.com/datawright-labs/website-screenshot): bulk full-page screenshots and PDFs.
- [SSL Certificate Checker](https://apify.com/datawright-labs/ssl-certificate-checker): bulk SSL certificate and domain expiry checks with alerts for expiring, invalid or outdated TLS.
- [SPF, DMARC & DKIM Checker](https://apify.com/datawright-labs/email-domain-dns-checker): bulk email domain audit of SPF (10-lookup limit), DMARC, DKIM, MX provider, BIMI and MTA-STS.
- [WHOIS Domain Lookup (RDAP)](https://apify.com/datawright-labs/whois-rdap-domain-lookup): bulk registrar, domain age, expiry date, nameservers, EPP status and availability from official registry RDAP.
- [Google Autocomplete Keyword Scraper](https://apify.com/datawright-labs/autocomplete-keyword-scraper): long-tail keyword ideas from Google, YouTube and Bing.
- [Greenhouse, Lever & Ashby Jobs Scraper](https://apify.com/datawright-labs/ats-jobs-scraper): normalized job feeds from 5 ATS platforms.
- [App Store Top Charts & Rank Tracker](https://apify.com/datawright-labs/app-store-top-charts): daily top free/paid/grossing app rankings with rank changes.

Tip: pair it with the **Sitemap URL Extractor** to audit the meta tags of every page in a sitemap, and the **Redirect Checker** to make sure old URLs land on pages with the right canonical.

Made by **Datawright Labs**: reliable, fairly priced web data tools. Questions or a missing feature? Open an issue on the Issues tab; we usually reply within a day.

# Actor input Schema

## `urls` (type: `array`):

Pages to check, one per line: full URLs or bare domains (example.com is checked as https://example.com/). Redirects are followed and the final page is analyzed. Duplicates are merged. Tip: get every page of a site with the Sitemap URL Extractor first.

## `checkOgImage` (type: `boolean`):

Request each og:image and report its HTTP status, content type and size; a broken preview image is flagged as a problem.

## `includeRawJsonLd` (type: `boolean`):

Also save the full parsed JSON-LD (schema.org) blocks of each page in a jsonLd field, e.g. to extract product, article or organization data.

## `outputFilter` (type: `string`):

Skipped rows are not saved and not charged.

## `userAgent` (type: `string`):

Some sites serve different meta tags to bots, social crawlers or phones. Note: many sites behind Cloudflare/Akamai block the Googlebot and Facebook user agents when they don't come from Google's or Facebook's own IPs; use Desktop Chrome for those (blocked pages are free).

## `timeoutSecs` (type: `integer`):

Per request.

## `concurrency` (type: `integer`):

URLs checked in parallel (max 4 at a time per host).

## Actor input object example

```json
{
  "urls": [
    "https://apify.com",
    "https://github.com/apify/crawlee",
    "https://www.bbc.com/news"
  ],
  "checkOgImage": true,
  "includeRawJsonLd": false,
  "outputFilter": "all",
  "userAgent": "browser",
  "timeoutSecs": 20,
  "concurrency": 10
}
```

# Actor output Schema

## `results` (type: `string`):

Per-URL meta tag results.

## `summary` (type: `string`):

SUMMARY record with counts and duplicate titles/descriptions.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "urls": [
        "https://apify.com",
        "https://github.com/apify/crawlee",
        "https://www.bbc.com/news"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("datawright-labs/meta-tags-checker").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "urls": [
        "https://apify.com",
        "https://github.com/apify/crawlee",
        "https://www.bbc.com/news",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("datawright-labs/meta-tags-checker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "urls": [
    "https://apify.com",
    "https://github.com/apify/crawlee",
    "https://www.bbc.com/news"
  ]
}' |
apify call datawright-labs/meta-tags-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datawright-labs/meta-tags-checker"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/kR80NsHodoAuLXd8e/builds/C0j5HWQZugnUcDRFG/openapi.json