# Structured Data Scraper & Validator (`taroyamada/structured-data-validator`) Actor

Validate JSON-LD and Microdata on public pages. No API key / no login. Open Input → leave defaults → Start (1 URL ≈ USD 0.01 total): https://console.apify.com/actors/LupMh9Kdj6vgwlHMb/input

- **URL**: https://apify.com/taroyamada/structured-data-validator.md
- **Developed by:** [naoki anzai](https://apify.com/taroyamada) (community)
- **Categories:** SEO tools, Developer tools, AI
- **Features:** Limited permissions
- **Stats:** 6 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $9.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Structured Data Validator API | Schema Coverage & Errors

**What you get:** one row per page with every JSON-LD and Microdata item found, schema errors and warnings, and a 0–100 structured-data score with an A–F grade.

Sample output from a real run (2026-10-18, default input, 2 rows):

| url | JSON-LD types | Microdata types | grade (score) | errors |
|---|---|---|---|---|
| https://www.google.com | – | schema.org/WebPage | C (40) | none |
| https://github.com | – | – | F (0) | no_structured_data: No JSON-LD or Microdata found on this page |

That run was one Actor start ($0.001) + 2 page rows × $0.009 = $0.019.

**CTA:** Open **Input** (link below) → leave defaults (2 URLs) → **Start**. First paid proof ≈ **USD 0.019**.
[Open Input (leave defaults → Start)](https://console.apify.com/actors/LupMh9Kdj6vgwlHMb/input)
Paid first run ≈ **USD 0.01 total** (1 URL). Keep reports, exports, and movement options off for the first run. Open Console Input (deep link above) and run this JSON.

```json
{
  "urls": [
    "https://schema.org"
  ],
  "concurrency": 1,
  "delivery": "dataset",
  "dryRun": false
}
```

Paste URL and Start.

### After this run

Turn this Actor's output into a capped paid report with [Website RAG Readiness Audit Report](https://apify.com/taroyamada/website-rag-readiness-audit?utm_source=apify_internal\&utm_medium=readme_after_run\&utm_campaign=v37_internal_flow\&utm_content=structured-data-validator__website-rag-readiness-audit).
Use it when AI builders, documentation teams, support teams, and technical marketers need to decide whether public website pages are clean and complete enough for RAG ingestion.

- First report: $9 / `website_rag_snapshot_report`; set `maxChargeUsd` to $9.
- Deeper report: $29 / `website_rag_readiness_report`; use only when the first result needs competitor or action-depth.
- This is an internal Apify flow aid. It is not revenue proof until accounted paid usage appears.

Crawling websites to extract structured data is essential for maintaining robust organic search visibility. Broken markup often goes unnoticed until traffic and rich snippets drop, costing you valuable clicks. This schema validation tool acts as a rigorous web scraper that parses every page to evaluate JSON-LD and Microdata quality at scale. Instead of manually checking individual URLs in external tools, you can schedule automated schema audits across thousands of pages to ensure semantic web standards are perfectly maintained.

Built for technical SEO and recurring compliance workflows, this scraper identifies missing schema fields, exposes invalid JSON syntaxes, and flags recommended Schema.org properties you might have overlooked. Every page scraped receives a clear 0-100 quality score, giving SEO and operations teams immediate, actionable insight into technical website health.

Easily schedule daily or weekly runs to monitor critical landing pages, product pages, or massive URL lists. By extracting the exact schema output mapped against search engine guidelines, you can rapidly export a comprehensive health report, catch syntax errors early, and secure your organic SERP real estate without manual intervention.

### Store Quickstart

- Start with `Quickstart (Dataset)` to validate the score and error model on two public pages.
- For full audits, use `Batch Validation` for multi-page quality scoring.
- For recurring monitoring, use `Webhook Alert` to catch schema errors immediately.

### Use with Apify MCP

Exact actor: `taroyamada/structured-data-validator`

Sample input JSON:

```json
{
  "urls": [
    "https://www.google.com"
  ],
  "concurrency": 3,
  "delivery": "dataset"
}
```

### Key Features

- 🔍 **JSON-LD + Microdata extraction** — Both formats supported
- 📊 **Quality scoring** — 0-100 with A-F grade per page
- ⚠️ **Error detection** — Missing `@type`, invalid JSON, missing `@context`
- 💡 **Warnings** — Sparse data, missing recommended properties
- 📋 **Bulk processing** — Check up to 200 URLs per run
- 🪝 **Webhook delivery** — Integrate into SEO monitoring workflows

### Use Cases

| Who | Why |
|-----|-----|
| Developers | Automate recurring data fetches without building custom scrapers |
| Data teams | Pipe structured output into analytics warehouses |
| Ops teams | Monitor changes via webhook alerts |
| Product managers | Track competitor/market signals without engineering time |

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| urls | array | prefilled | List of page URLs to check for Schema.org structured data (JSON-LD, Microdata). Max 200. |
| delivery | string | `"dataset"` | How to deliver results. 'dataset' saves to Apify Dataset (recommended), 'webhook' sends to a URL. |
| webhookUrl | string | — | Webhook URL to send results to (only used when delivery is 'webhook'). Works with Slack, Discord, or any HTTP endpoint. |
| concurrency | integer | `3` | Maximum number of parallel requests. Higher = faster but may trigger rate limits. |
| dryRun | boolean | `false` | If true, runs without saving results or sending webhooks. Useful for testing. |

#### Input Example

```json
{
  "urls": ["https://www.google.com", "https://github.com", "https://schema.org"],
  "concurrency": 3
}
```

### Input Examples

#### Example: Single page validation

```json
{
  "urls": [
    "https://schema.org"
  ]
}
```

#### Example: Several pages from one site

```json
{
  "urls": [
    "https://schema.org",
    "https://schema.org/Product",
    "https://schema.org/docs/gs.html"
  ],
  "concurrency": 3
}
```

#### Example: Competitor batch with a spend cap

```json
{
  "urls": [
    "https://www.google.com",
    "https://github.com",
    "https://schema.org"
  ],
  "concurrency": 3,
  "maxChargeUsd": 0.05
}
```

### Output

One dataset row per URL.

| Field | Type | Description |
|-------|------|-------------|
| `url` | string | Page checked |
| `jsonLd` | object\[] | JSON-LD items found (`type`, `context`, `name`, …) |
| `microdata` | object\[] | Microdata items found (`type`, `format`) |
| `errors` | string\[] | Schema errors (for example `no_structured_data`) |
| `warnings` | string\[] | Non-blocking issues |
| `score` | object | `total` (0–100) and `grade` (A–F) |
| `error` | string or null | Fetch error, if any |
| `checkedAt` | timestamp | When the page was checked |

#### Output Example

Row from a real run on https://schema.org (2026-10-18, trimmed):

```json
{
  "url": "https://schema.org",
  "jsonLd": [
    {
      "type": "WebSite",
      "context": "https://schema.org",
      "name": "Schema.org",
      "url": "https://schema.org"
    }
  ],
  "microdata": [],
  "errors": [],
  "warnings": [],
  "score": {
    "total": 80,
    "grade": "A"
  },
  "error": null,
  "checkedAt": "2026-10-18T11:44:51.096Z"
}
```

### API Usage

Run this actor programmatically using the Apify API. Replace `YOUR_API_TOKEN` with your token from [Apify Console → Settings → Integrations](https://console.apify.com/account/integrations).

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/taroyamada~structured-data-validator/run-sync-get-dataset-items?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "urls": ["https://www.google.com", "https://github.com", "https://schema.org"], "concurrency": 3 }'
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("taroyamada/structured-data-validator").call(run_input={
  "urls": ["https://www.google.com", "https://github.com", "https://schema.org"],
  "concurrency": 3
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

#### JavaScript / Node.js

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('taroyamada/structured-data-validator').call({
  "urls": ["https://www.google.com", "https://github.com", "https://schema.org"],
  "concurrency": 3
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Tips & Limitations

- Keep concurrency ≤ 5 when auditing production sites to avoid WAF rate-limit triggers.
- Use webhook delivery for recurring cron runs — push only deltas to downstream systems.
- Enable `dryRun` for cheap validation before committing to a paid cron schedule.
- Results are dataset-first; use Apify API `run-sync-get-dataset-items` for instant JSON in CI pipelines.
- Run a tiny URL count first, review the sample, then scale up — pay-per-event means you only pay for what you use.

### See also (SEO audit cluster)

- [Sitemap Scraper & XML Analyzer](https://apify.com/taroyamada/sitemap-analyzer) — Parse and audit XML sitemaps as a discovery layer feeding structured-data validation.

### FAQ

**Is there a rate limit?**

Built-in concurrency throttling keeps requests polite. For most public APIs this actor can run 1–10 parallel requests without issues.

**What happens when the input URL is unreachable?**

The actor records an error row with the failure reason — successful URLs keep processing.

**Can I schedule recurring runs?**

Yes — use Apify Schedules to run this actor on a cron (hourly, daily, weekly). Combine with webhook delivery for change alerts.

**Does this actor respect robots.txt?**

Yes — requests use a standard User-Agent and honor site rate limits. For aggressive audits, set a higher `concurrency` only on your own properties.

**Can I integrate with Google Sheets or Airtable?**

Use webhook delivery with a Zapier/Make/n8n catcher, or call the Apify REST API from Apps Script / Airtable automations.

### Complete Your Website Health Audit

**Website Health Suite** — Build a comprehensive compliance and trust monitoring workflow:

**1. Link & URL Health**

- [🔗 Broken Link Checker](https://apify.com/taroyamada/broken-link-checker) — Find broken links across your entire site structure
- [🔗 Bulk URL Health Checker](https://apify.com/taroyamada/bulk-url-health-checker) — Validate HTTP status, redirects, SSL, and response times

**2. SEO & Metadata Quality** (you are here)

- [Schema.org Validator](https://apify.com/taroyamada/structured-data-validator) — Validate JSON-LD and Microdata with quality scoring
- [🏷️ Meta Tag Analyzer](https://apify.com/taroyamada/meta-tag-analyzer) — Audit title tags, Open Graph, Twitter Cards, and hreflang

**3. Security & Email Deliverability**

- [DNS/DMARC Security Checker](https://apify.com/taroyamada/dns-dmarc-security-checker) — Audit SPF, DKIM, DMARC, and MX records

**4. Historical Data & Recovery**

- [📚 Wayback Machine Checker](https://apify.com/taroyamada/wayback-machine-checker) — Find archived snapshots for content recovery

**Recommended workflow**: Weekly schema validation → Fix errors/warnings → Validate metadata with Meta Tag Analyzer → Monitor with webhooks → Track rich snippet performance in Search Console.

**Other Website Tools:**

- [Sitemap Analyzer](https://apify.com/taroyamada/sitemap-analyzer) — SEO sitemap audit
- [Site Governance Monitor](https://apify.com/taroyamada/site-governance-monitor) — Robots.txt and schema monitoring
- [Domain Trust Monitor](https://apify.com/taroyamada/domain-trust-monitor) — SSL expiry and security headers

### Cost

**Pay Per Event** (current Store prices):

- Actor start: $0.001 per run
- Result row: $0.009 per row written to the default dataset

**Example**: 1,000 rows = $0.001 + (1,000 × $0.009) = **$9.00**

No subscription required — you only pay for what you use.

> 💾 **Save it for later**: click the bookmark icon at the top of the Apify Store page if you'd like to come back to it. Bookmarks help other engineers find this actor via Apify's discovery surfaces.

### ⭐ Was Structured Data Scraper & Validator useful for your JSON-LD / Schema.org audit?

If this actor saved you time, **[please leave a 5★ rating on Apify Store](https://apify.com/taroyamada/structured-data-validator/reviews)** — it takes 10 seconds, helps other engineers and analysts discover it, and keeps updates free.

Have a feature request, bug, or sample workflow you'd like to share? **[Open an issue](https://apify.com/taroyamada/structured-data-validator/issues)** — we read every one and use them to prioritise the next release.

### Related report Actors

Use these follow-on Actors when you want a capped, decision-ready report instead of more raw rows. They use public or user-provided inputs, respect `maxChargeUsd`, and do not promise rankings, revenue, conversion lifts, or sales outcomes.

- [Website RAG Readiness Audit](https://apify.com/taroyamada/website-rag-readiness-audit) - add retrieval risk, source coverage, and cleanup actions after technical page checks.

### Related paid report workflows

If this Actor gave you raw rows or source context, these follow-on report Actors are designed for a small capped paid run. They help make a decision, not just collect more data.

- [Website RAG Readiness Audit Report](https://apify.com/taroyamada/website-rag-readiness-audit) - decide whether public website pages are clean and complete enough for RAG ingestion. Entry $9 / `website_rag_snapshot_report`; premium $29 / `website_rag_readiness_report`.

Keep `maxChargeUsd` equal to the selected tier. Internal links are traffic aids only; real proof requires accounted paid usage.

### Related report Actors

Use these follow-on Actors when you want a capped, decision-ready report instead of more raw rows. They use public or user-provided inputs, respect `maxChargeUsd`, and do not promise rankings, revenue, conversion lifts, or sales outcomes.

- [Website RAG Readiness Audit](https://apify.com/taroyamada/website-rag-readiness-audit) - add retrieval risk, source coverage, and cleanup actions after technical page checks.

# Actor input Schema

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

Leave the 2 prefilled page URLs and click Start for the first run. Or paste public pages where you want to validate JSON-LD and Microdata.

## `delivery` (type: `string`):

How to deliver results. 'dataset' saves to Apify Dataset (recommended), 'webhook' sends to a URL.

## `webhookUrl` (type: `string`):

Webhook URL to send results to (only used when delivery is 'webhook'). Works with Slack, Discord, or any HTTP endpoint.

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

Maximum number of parallel requests. Higher = faster but may trigger rate limits.

## `dryRun` (type: `boolean`):

If true, runs without saving results or sending webhooks. Useful for testing.

## `maxChargeUsd` (type: `number`):

Safety cap for this run. Billable rows beyond this cap are returned as no-charge limit_reached summaries.

## Actor input object example

```json
{
  "urls": [
    "https://schema.org"
  ],
  "delivery": "dataset",
  "concurrency": 1,
  "dryRun": false,
  "maxChargeUsd": 0.03
}
```

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

// Run the Actor and wait for it to finish
const run = await client.actor("taroyamada/structured-data-validator").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://schema.org"] }

# Run the Actor and wait for it to finish
run = client.actor("taroyamada/structured-data-validator").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://schema.org"
  ]
}' |
apify call taroyamada/structured-data-validator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,taroyamada/structured-data-validator"
        }
    }
}
```

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/LupMh9Kdj6vgwlHMb/builds/5BtgW52NS8auM00ut/openapi.json