# HTML SEO & JSON-LD Syntax Checker — PageProof (`coolish_indium/pageproof-preflight`) Actor

Check supplied HTML snapshots before deploying generated websites. Find metadata, canonical, image-alt, noindex and JSON-LD syntax issues with source-line evidence and fixes as JSON. API/MCP ready. 1–20 pages per run; $0.01/page + $0.00005/run. No URL crawling.

- **URL**: https://apify.com/coolish_indium/pageproof-preflight.md
- **Developed by:** [Cody J](https://apify.com/coolish_indium) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 completed page audits

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

## HTML SEO & JSON-LD Syntax Checker — PageProof

Inspect supplied HTML snapshots before publishing. Get reproducible JSON reports with stable rule IDs, severity, source-line references, evidence, and suggested fixes. Useful for website-building agents and repeatable release QA.

**Supply the HTML yourself. URL fields are labels and are never fetched.** PageProof does not crawl websites, render JavaScript, or call a paid AI model.

### Check one real page now

Already using Apify? A single completed page check currently costs **$0.01005 total**, including the run start and platform usage.

1. [Open PageProof in Console](https://console.apify.com/actors/1loSRgmRVQDr3Zcta) and sign in to your own Apify account.
2. In Input, keep exactly one object in `pages`. Replace its `html` with your actual generated HTML and its `url` with the intended page URL label. Do not submit secrets.
3. Set the maximum charge to **0.01005 USD** for that one-page run, then start it once.
4. Open the completed run's dataset to read the JSON report. Inspect findings and suggested fixes before deploying. A report with findings is a completed, billable check.

For an AI agent, use the capped API request or MCP configuration below. If a request disconnects, inspect the original run before submitting again.

### Price and a first API request

Current price: **$0.01 per completed page + $0.00005 per run start**, including platform usage. One page needs a maximum-charge budget of **$0.01005**; a full 20-page batch needs **$0.20005**. A report with findings is still a completed result. Confirm current prices in the Pricing panel.

Use PageProof between generating HTML and publishing: require one report for every submitted page, inspect `summary.error`, and route relevant warning codes back to your release workflow. The URL labels the supplied snapshot and is never fetched.

Save the example below as `input.json`. With your own Apify token in the `APIFY_TOKEN` environment variable, this Bash-compatible request returns reports to `report.json` with a one-page charge cap:

```bash
curl --fail-with-body --max-time 330 \
  --request POST \
  --header "Authorization: Bearer ${APIFY_TOKEN}" \
  --header "Content-Type: application/json" \
  --data-binary @input.json \
  --output report.json \
  "https://api.apify.com/v2/actors/1loSRgmRVQDr3Zcta/run-sync-get-dataset-items?maxTotalChargeUsd=0.01005&timeout=60&memory=256&restartOnError=false&format=json"
```

For 20 snapshots, use a cap of `maxTotalChargeUsd=0.20005`. Count returned reports: a lower cap may stop the batch early. HTTP success does not mean the pages passed inspection. Do not automatically retry a disconnected POST; the first run may still be processing. Check Console before submitting again. Keep tokens in environment variables or a secret manager.

[Official API reference](https://docs.apify.com/api/v2/actor-run-sync-get-dataset-items-post)

### Run a check

1. Put one or more HTML snapshots in the `pages` array.
2. Supply an absolute HTTP(S) `url` and nonempty `html` for each page. An optional `id` identifies the result; IDs must be unique within the batch. Omitted IDs become `page-1`, `page-2`, and so on.
3. Read one report per completed page from the default dataset. If the buyer charge limit stops a batch early, only completed reports will be present.

```json
{"pages":[{"id":"home","url":"https://example.com/","html":"<h1>Hello</h1>"}]}
```

This deliberately incomplete snapshot produces an excerpt like:

```json
{"id":"home","summary":{"error":0,"warning":2,"info":1},"findings":[{"code":"TITLE_MISSING","severity":"warning"},{"code":"DESCRIPTION_MISSING","severity":"warning"},{"code":"CANONICAL_MISSING","severity":"info"}]}
```

Full reports also include each finding's message, evidence, location, suggested fix, page facts, an HTML SHA-256 hash, and explicit scope limits. `summary.error` counts failed JSON syntax checks. Warning and information findings require context.

### Checks and limits

Checks cover missing or duplicate titles/descriptions, multiple or unusable canonical links, missing h1 and image alt attributes, declared noindex directives, and JSON-LD syntax. Empty alt attributes for decorative images and intentionally noindexed pages are not treated as errors.

Submit 1–20 pages, at most 250000 UTF-8 HTML bytes per page and 2000000 HTML bytes per batch. Optional `status` is a caller-supplied integer from 100 to 599; it is not a response verified by this service. Invalid batches are rejected before any result is produced. Do not submit sensitive content or secrets.

This is static source inspection. It does not check HTTP headers, certify accessibility, validate all HTML/JSON-LD semantics, establish Google rich-result eligibility, or predict search rankings. No findings does not certify a whole site. JavaScript-generated content must already be included in the supplied snapshot.

### Billing

Consult the Pricing panel for current prices. Each persisted page report uses one automatic dataset-item event. A report containing findings is still a completed, billable result. The platform run-start event can also apply, even when runtime validation fails or no page completes. Set a maximum charge for the run and account for both event types when budgeting a batch.

### Connect an AI agent with MCP

Add this remote MCP server URL to your compatible client:

```text
https://mcp.apify.com/?tools=search-actors,fetch-actor-details,coolish_indium/pageproof-preflight
```

Authorize with your own Apify account through OAuth, or use a buyer-funded prepaid token through Apify agentic payments. Discovery access does not include paid execution. Keep the token in your client's secure configuration.

Ask your agent to inspect `coolish_indium/pageproof-preflight`, supply HTML snapshots using its input schema, set the run charge cap for the batch, and read the completed dataset reports. Tool names vary by client. Actor runs and dataset access require authorization.

[Apify MCP setup documentation](https://docs.apify.com/mcp)

# Actor input Schema

## `pages` (type: `array`):

1-20 objects with optional id, required url label (never fetched), required html (at most 250000 UTF-8 bytes), and optional status. Maximum 2000000 HTML bytes per batch. Each completed page produces one billable result. No sensitive content.

## Actor input object example

```json
{
  "pages": [
    {
      "id": "home",
      "url": "https://example.com/",
      "html": "<h1>Hello</h1>"
    }
  ]
}
```

# Actor output Schema

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

JSON reports with page identifiers, severity counts, findings with evidence and suggested fixes, source hashes, page facts, and scope limits.

# 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 = {
    "pages": [
        {
            "id": "home",
            "url": "https://example.com/",
            "html": "<h1>Hello</h1>"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("coolish_indium/pageproof-preflight").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 = { "pages": [{
            "id": "home",
            "url": "https://example.com/",
            "html": "<h1>Hello</h1>",
        }] }

# Run the Actor and wait for it to finish
run = client.actor("coolish_indium/pageproof-preflight").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 '{
  "pages": [
    {
      "id": "home",
      "url": "https://example.com/",
      "html": "<h1>Hello</h1>"
    }
  ]
}' |
apify call coolish_indium/pageproof-preflight --silent --output-dataset

```

## MCP server setup

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

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/1loSRgmRVQDr3Zcta/builds/vYw8RimcEsBPPm8Y9/openapi.json