# Structured Data & Social Preview Validator (`zaden/my-actor-6`) Actor

Validates JSON-LD/schema.org structured data plus Open Graph and Twitter Card tags for any URL. Fast, no browser needed. Need every check? See Full Site Health Suite for all 9 checks in one job.

- **URL**: https://apify.com/zaden/my-actor-6.md
- **Developed by:** [Zaden](https://apify.com/zaden) (community)
- **Categories:** SEO tools, Developer tools, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.60 / 1,000 page validateds

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Structured Data & Social Preview Validator

A fast, no-browser check of the tags that control how your pages appear in Google's rich results and in social link previews. Point it at one or more URLs and get back JSON-LD/schema.org validation, Open Graph tags, and Twitter Card tags -- plus a **letter grade**, a 0-100 score, a severity tag, and a plain-English issue list.

### What you get, per URL

- A **letter grade (A+ to F)** and 0-100 score summarizing rich-result and social-preview readiness at a glance
- A one-line **executive summary** ("4 issue(s) found -- review recommended")
- A **severity** tag -- `critical` (page unreachable, missing `<title>`, or broken JSON-LD), `warning` (missing OG/Twitter tags or other issues), or `ok` -- for instant triage
- **JSON-LD structured data** -- every `@type` found on the page (Article, Product, Organization, and more), flagged if the JSON is malformed, and checked against the fields Google's rich-result docs recommend for common types
- **Open Graph tags** -- `og:title`, `og:description`, `og:image`, `og:type`, which control how the page previews on Facebook, LinkedIn, and Slack
- **Twitter Card tag** -- whether `twitter:card` is present, which controls the preview on X/Twitter
- **Basic on-page SEO** -- `<title>` and meta description presence
- Pages are checked **in parallel** (configurable, up to 20 at once), so a batch of 50 URLs finishes in a fraction of the time a one-by-one check would take

### Why this instead of checking manually

| | Manual spot-checks | Structured Data & Social Preview Validator |
|---|---|---|
| Coverage | Whatever page you remember to test | Every URL you list, automatically |
| Speed | One page at a time in a social debugger tool | Seconds, via parallel checking |
| Triage | You read raw JSON-LD and meta tags yourself | Pre-classified severity + letter grade |
| Repeatability | Forgotten after the next CMS template change | One click, or schedule it |
| Output | Screenshots of a preview tool | Structured dataset, exportable to CSV/JSON/BI tools |

### Who this is for

- Developers and marketers shipping a new page or blog post who want to confirm it will preview correctly when shared
- SEO teams auditing structured data across a site for rich-result eligibility
- Agencies doing a pre-launch checklist across a client's key pages
- Anyone who's shared a link and been embarrassed by a missing preview image

### How to use it

1. Add one or more **URLs to check**.
2. Tune **concurrency** (default 5) to trade speed for gentleness on slow servers.
3. Run it once for a snapshot, or put it on an Apify **Schedule** to catch a dropped meta tag after a CMS or template change.

### Example output (one item)

```json
{
  "url": "https://example.com/blog/post",
  "statusCode": 200,
  "score": 60,
  "grade": "D",
  "severity": "warning",
  "summary": "4 issue(s) found -- review recommended.",
  "issueCount": 4,
  "issues": [
    "No JSON-LD structured data found on this page.",
    "Missing og:image -- shared links will show no preview image.",
    "No Twitter Card tag found -- X/Twitter will fall back to Open Graph tags or show no preview.",
    "Missing meta description tag."
  ],
  "structuredDataFound": false,
  "structuredDataTypes": [],
  "hasOpenGraph": true,
  "ogTitle": "Example Blog Post",
  "ogImage": null,
  "hasTwitterCard": false,
  "checkedAt": "2026-08-22T00:00:00.000Z"
}
```

### Pricing

This Actor uses pay-per-event pricing:

- **Page validated** -- charged once per URL processed.

Parallel checking doesn't cost more -- it just finishes faster.

### FAQ

**Does this render JavaScript-injected tags?**
No. It reads the raw HTML response, the same way search engine and social media crawlers typically do for meta tags. If your tags are injected client-side by JavaScript after page load, they won't be seen here -- which is itself a useful signal, since many crawlers behave the same way.

**Which schema.org types does it validate fields for?**
Article/NewsArticle/BlogPosting, Product, Organization, LocalBusiness, Recipe, Event, BreadcrumbList, and FAQPage, based on Google's commonly documented required/recommended properties. Other types are still detected and listed, just not field-checked.

**What makes something "critical" vs. a "warning"?**
`critical` covers page-breaking problems: the page couldn't be fetched, has no `<title>` tag, or has JSON-LD that fails to parse. `warning` covers everything else that lowers the score, most commonly missing Open Graph or Twitter Card tags -- worth fixing, but the page still loads and functions.

**Will higher concurrency get me rate-limited?**
It can, on servers with aggressive rate limiting. Start at the default (5) and lower it if you see timeouts spike for a particular site.

**Does this send any data anywhere besides your own Apify account?**
No. It only fetches the URLs you provide and returns what it finds -- no login, no third-party analytics calls.

# Actor input Schema

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

One or more URLs. JSON-LD structured data and Open Graph/Twitter Card tags are checked once per URL.

## `requestTimeoutSecs` (type: `integer`):

How long to wait for each page to load before giving up.

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

How many pages to fetch and validate in parallel. Higher values finish faster at the same cost; lower values are gentler on slow servers.

## Actor input object example

```json
{
  "urls": [
    "https://example.com/"
  ],
  "requestTimeoutSecs": 15,
  "concurrency": 5
}
```

# Actor output Schema

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

JSON-LD structured data and social preview tag status for each checked URL.

# 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://example.com/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("zaden/my-actor-6").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://example.com/"] }

# Run the Actor and wait for it to finish
run = client.actor("zaden/my-actor-6").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://example.com/"
  ]
}' |
apify call zaden/my-actor-6 --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,zaden/my-actor-6"
        }
    }
}

```

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/erhXbYEhy2CpPDcIn/builds/ffJgUvulwr3lhTFwB/openapi.json