# Schema.org Rich Result Audit: JSON-LD Structured Data Check (`transparent_meteorite/schema-org-rich-result-audit`) Actor

Audit schema.org structured data on any list of pages: JSON-LD, Microdata and RDFa extracted and checked against Google rich result required and recommended properties. Eligible yes/no per type, errors, warnings, raw blocks, optional crawl.

- **URL**: https://apify.com/transparent_meteorite/schema-org-rich-result-audit.md
- **Developed by:** [Detroit Web Agent - Open Data](https://apify.com/transparent_meteorite) (community)
- **Categories:** SEO tools, Developer tools
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.40 / 1,000 page auditeds

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

## Schema Markup Validator

Give it page URLs, or let it crawl a site, and see for each page which Google rich results its schema.org markup is eligible for. It extracts JSON-LD, Microdata and RDFa, checks each item against the required and recommended properties in Google Search Central, and lists exact errors and warnings with the raw blocks. It uses plain HTTP: no browser and no login.

### What data you get

- **Verdict per page:** `auditStatus` (valid, valid-with-warnings, has-errors, no-rich-result-types, no-structured-data) and a 0-100 `auditScore`
- **Per rich-result item:** feature, `@type`, name, source format, eligible yes/no, missing required and recommended properties, errors, warnings, notes
- **Types:** every schema.org type found, which ones Google uses for rich results, eligible and ineligible lists
- **Raw markup:** JSON-LD blocks, Microdata items and RDFa items as JSON, plus JSON-LD syntax errors
- **Fetch facts:** final URL, HTTP status, response time, crawl depth, noindex flag

### Use cases

- Audit a client's product, recipe, article and local business pages and hand over an exact fix list
- Re-run on a schedule after each release and catch templates that lose Product, Article or breadcrumb eligibility
- Inventory which schema.org types and formats competitors use across a crawl of their site

### How it works

1. Each URL is fetched over HTTPS with a desktop browser user agent, following up to 10 redirects. Non-HTML answers are skipped.
2. JSON-LD (including `@graph` and arrays), Microdata (`itemscope`, `itemprop`, `itemref`) and schema.org RDFa (`typeof`, `property`) are parsed into one model. `@id` references are resolved across blocks.
3. Each rich-result candidate (top-level items and nested ones such as `mainEntity`, list items, `aggregateRating` and `review`) is checked with rules per Google feature: required properties, recommended properties, ISO 8601 dates and durations, schema.org enum values, absolute URLs, rating ranges and expiry dates.
4. Optional crawl: set `maxPagesPerSite` and the actor follows same-site links up to `maxCrawlDepth`, honoring robots.txt.

Checked features: Product (and ProductGroup), Offer, AggregateRating, Review, Article / NewsArticle / BlogPosting, BreadcrumbList, FAQPage, HowTo, LocalBusiness and its subtypes (Restaurant, Store, Dentist, Hotel and 100+ more), Organization, Event, Recipe, JobPosting, VideoObject and SoftwareApplication (including MobileApplication and WebApplication).

### Input

| Field | What it does | Default |
|---|---|---|
| `urls` | Page URLs to audit, one per line (up to 5,000). | required |
| `maxPagesPerSite` | 0 audits only the listed URLs. Above 0, also crawls same-site links up to this many pages per site (max 500). | 0 |
| `maxCrawlDepth` | How many clicks away from a start URL the crawl may go (1-5). | 2 |
| `onlyWithStructuredData` | Leave pages without any markup out of the results (they are not charged). | false |
| `maxUrls` | Upper limit of pages audited in one run. | 1000 |
| `requestTimeoutSecs` | Time limit per page (3-60 seconds). | 15 |
| `maxConcurrency` | Pages fetched at the same time (1-25). | 10 |
| `includeRawBlocks` | Keep raw JSON-LD, Microdata and RDFa in each row. Turn off for a flat CSV. | true |
| `proxyConfiguration` | Optional Apify Proxy for sites that refuse cloud IPs. | off |

#### Example input

```json
{
  "urls": ["https://www.bbcgoodfood.com/recipes/easy-pancakes", "https://www.allbirds.com/products/mens-tree-runners"],
  "maxPagesPerSite": 0,
  "requestTimeoutSecs": 15
}
```

### Output

One dataset row per audited page. The **Audit** view shows verdict, score and eligible types; **Issues** shows every error and warning; **Fetch status** shows status codes, crawl depth and what was charged. Export as JSON, CSV, Excel or HTML, or read through the API. A run summary (pages audited, eligible items by type, errors by code) is saved as the `OUTPUT` record.

#### Sample output

Trimmed row (raw blocks shortened):

```json
{
  "url": "https://www.bbcgoodfood.com/recipes/easy-pancakes",
  "statusCode": 200,
  "ok": true,
  "billed": true,
  "pageTitle": "Easy pancakes recipe | Good Food",
  "auditStatus": "valid-with-warnings",
  "auditScore": 98,
  "formats": ["json-ld"],
  "jsonLdBlockCount": 4,
  "typesFound": ["VideoObject", "Recipe", "ImageObject", "WebPage", "Person", "Organization", "NutritionInformation", "HowToStep", "BreadcrumbList", "ListItem", "AggregateRating"],
  "eligibleTypes": ["VideoObject", "Recipe", "BreadcrumbList", "AggregateRating"],
  "ineligibleTypes": [],
  "errorCount": 0,
  "warningCount": 3,
  "warnings": ["VideoObject \"How to make perfect pancakes\": Missing recommended property description", "Recipe \"Easy pancakes\": Missing recommended property aggregateRating", "..."],
  "richResults": [{"feature": "Recipe", "type": "Recipe", "source": "json-ld", "name": "Easy pancakes", "eligible": true, "errors": [], "missingRequired": [], "missingRecommended": ["aggregateRating", "video"]}],
  "summary": "11 type(s) in json-ld; 4 rich-result item(s): eligible VideoObject, Recipe, BreadcrumbList, AggregateRating; 0 error(s), 3 warning(s).",
  "rawJsonLd": [{"@context": "https://schema.org", "@type": "VideoObject", "name": "How to make perfect pancakes"}],
  "fetchedAt": "2026-11-08T06:01:48.325Z"
}
```

Typical errors it reports: `Product needs at least one of offers, review or aggregateRating`, `Invalid offers.price "$19.99": use a plain number with a dot decimal, no currency symbol or thousands separator`, `Invalid date in startDate: "March 3" (use ISO 8601, e.g. 2026-03-01 or 2026-03-01T09:00:00-05:00)`, `validThrough is in the past: the job has expired and should be removed or updated`, `Missing required property itemListElement (found "ItemListElement"; property names are case-sensitive)`.

### Pricing

Pay per event, no monthly fee:

- **Page audited:** $0.0014 per page fetched and audited ($1.40 per 1,000 pages).
- **Actor start:** $0.00005 per run.

Pages that time out, answer 4xx/5xx, are not HTML, are blocked by robots.txt in crawl mode, or are skipped by `onlyWithStructuredData` are **never charged**. If no input URL is usable the run stops at once with a clear message. Set "Maximum cost per run" in run options to cap spend; the actor stops cleanly at that limit.

### Call it from code

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("transparent_meteorite/schema-org-rich-result-audit").call(run_input={"urls": ["https://www.bbcgoodfood.com/recipes/easy-pancakes"]})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["url"], row["auditStatus"], row["auditScore"])
```

cURL (starts a run and waits for the rows):

```bash
curl -X POST "https://api.apify.com/v2/acts/transparent_meteorite~schema-org-rich-result-audit/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN"   -H "Content-Type: application/json"   -d '{"urls": ["https://www.bbcgoodfood.com/recipes/easy-pancakes"]}'
```

The actor also works as a tool for AI agents through the Apify MCP server (`https://mcp.apify.com`), using the same input.

### FAQ

**Is this the same as Google's Rich Results Test?** It applies the same published property rules, in bulk and with a crawl. Google also weighs site quality and policy, so eligible means the markup qualifies, not that Google will always show the result.

**Why is HowTo never eligible?** Google retired HowTo rich results. FAQ rich results are shown only for well-known government and health sites; the actor validates FAQPage and adds a note.

**Does it run JavaScript?** No. It reads the server HTML, as most crawlers do on first pass. Markup injected only by client-side scripts is not seen.

**Why did a page return 403?** Some sites refuse cloud IPs. Turn on Apify Proxy and retry. The actor does not bypass captchas or logins; those pages come back as errors and are not charged.

### Limits

- Up to 5,000 pages per run, 500 per site in crawl mode; 2 MB of HTML per page.
- Only public http(s) URLs; localhost and private IP ranges are refused.
- RDFa is read for schema.org vocabulary only. Raw blocks are capped at 100 KB per row (`rawTruncated` tells you).
- Rules follow Google Search Central documentation as of November 2026.

### Related actors

- [Technical SEO Page Audit](https://apify.com/transparent_meteorite/technical-seo-page-audit): titles, headings, canonicals and indexability for the same pages.
- [Sitemap Link Inventory](https://apify.com/transparent_meteorite/sitemap-link-inventory): pull every URL from a site's sitemaps, then audit them here.
- [Website Tech Stack Detector](https://apify.com/transparent_meteorite/website-tech-stack-detector): see which CMS or e-commerce platform produced the markup.

# Actor input Schema

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

Public page URLs to audit, one per line, e.g. https://www.example.com/product/123. Up to 5,000 per run; duplicates are removed and URLs without a scheme get https://.

## `maxPagesPerSite` (type: `integer`):

Also audit up to this many same-site pages linked from each input URL, e.g. 20. 0 audits only the URLs you list. Crawled pages follow robots.txt and are charged like any audited page.

## `maxCrawlDepth` (type: `integer`):

How many clicks away from the input URL the crawl may go, e.g. 1 for pages linked directly from it. Only used when extra pages per site is above 0.

## `onlyWithStructuredData` (type: `boolean`):

Leave out (and do not charge) audited pages that have no JSON-LD, Microdata or RDFa at all. Useful in crawl mode.

## `maxUrls` (type: `integer`):

Upper limit on how many input URLs are processed in one run (hard cap 5,000), e.g. 100 for a quick sample. Extra URLs are skipped and never charged.

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

How long to wait for one page (all redirects included) before giving up, e.g. 15. Slow pages that time out are listed with error "timeout" and are not charged.

## `maxConcurrency` (type: `integer`):

How many pages are fetched at the same time, e.g. 10. Requests to the same site are spaced out politely; lower this if a site starts answering 429.

## `includeRawBlocks` (type: `boolean`):

Keep the parsed raw JSON-LD, Microdata and RDFa blocks in each row. Turn off for a smaller export.

## `proxyConfiguration` (type: `object`):

Optional. Requests go out directly by default, which suits most public sites. Turn on Apify Proxy (for example the datacenter group) only for sites that block cloud IP addresses; proxy traffic is billed by Apify on top.

## Actor input object example

```json
{
  "urls": [
    "https://www.bbcgoodfood.com/recipes/classic-lasagne",
    "https://apps.apple.com/us/app/duolingo-language-lessons/id570060128",
    "https://www.coursera.org/learn/machine-learning",
    "https://developer.mozilla.org/en-US/docs/Web/HTML",
    "https://apify.com"
  ],
  "maxPagesPerSite": 0,
  "maxCrawlDepth": 2,
  "onlyWithStructuredData": false,
  "maxUrls": 1000,
  "requestTimeoutSecs": 15,
  "maxConcurrency": 10,
  "includeRawBlocks": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `issues` (type: `string`):

No description

## `fetch` (type: `string`):

No description

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

No description

# 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://www.bbcgoodfood.com/recipes/classic-lasagne",
        "https://apps.apple.com/us/app/duolingo-language-lessons/id570060128",
        "https://www.coursera.org/learn/machine-learning",
        "https://developer.mozilla.org/en-US/docs/Web/HTML",
        "https://apify.com"
    ],
    "maxPagesPerSite": 0,
    "maxCrawlDepth": 2,
    "maxUrls": 1000,
    "requestTimeoutSecs": 15,
    "maxConcurrency": 10,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("transparent_meteorite/schema-org-rich-result-audit").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://www.bbcgoodfood.com/recipes/classic-lasagne",
        "https://apps.apple.com/us/app/duolingo-language-lessons/id570060128",
        "https://www.coursera.org/learn/machine-learning",
        "https://developer.mozilla.org/en-US/docs/Web/HTML",
        "https://apify.com",
    ],
    "maxPagesPerSite": 0,
    "maxCrawlDepth": 2,
    "maxUrls": 1000,
    "requestTimeoutSecs": 15,
    "maxConcurrency": 10,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("transparent_meteorite/schema-org-rich-result-audit").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://www.bbcgoodfood.com/recipes/classic-lasagne",
    "https://apps.apple.com/us/app/duolingo-language-lessons/id570060128",
    "https://www.coursera.org/learn/machine-learning",
    "https://developer.mozilla.org/en-US/docs/Web/HTML",
    "https://apify.com"
  ],
  "maxPagesPerSite": 0,
  "maxCrawlDepth": 2,
  "maxUrls": 1000,
  "requestTimeoutSecs": 15,
  "maxConcurrency": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call transparent_meteorite/schema-org-rich-result-audit --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,transparent_meteorite/schema-org-rich-result-audit"
        }
    }
}
```

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/XurIIW1GlujREcpnD/builds/UP6dBf4y9EusIiDjk/openapi.json
