# JSON-LD Structured Evidence Auditor (`flintglade/jsonld-structured-evidence-auditor`) Actor

Audit JSON-LD claims against visible evidence on explicit authorized pages with bounded, provenance-rich output.

- **URL**: https://apify.com/flintglade/jsonld-structured-evidence-auditor.md
- **Developed by:** [Flintglade](https://apify.com/flintglade) (community)
- **Categories:** SEO tools, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.00 / 1,000 structured evidence audits

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

## JSON-LD Structured Evidence Auditor

Audit JSON-LD on explicit web pages and compare selected structured claims with deterministic, source-located HTML evidence.

### What this Actor does

For each supplied HTTPS URL, AP-028 performs one bounded HTML GET, finds `application/ld+json` scripts, parses them with duplicate-key and non-finite-number rejection, inventories top-level and `@graph` entities, and compares supported claims with visible or machine-linked page evidence. It does not dereference remote JSON-LD contexts.

Supported comparisons include names/headlines, descriptions, URLs, images, SKU/MPN, brand/author names, publication dates, and Offer price, currency, and availability. Each claim is reported as `corroborated`, `not_corroborated`, `not_observable`, or `not_compared`, with JSON Pointer and HTML locators. This is evidence QA, not a complete JSON-LD processor, search-ranking guarantee, or Schema.org conformance certification.

### Input

The controlled default is:

```json
{
  "urls": ["https://flintglade-tools.github.io/apify-fixtures/jsonld/product.html"],
  "compareVisibleContent": true,
  "concurrency": 1
}
````

Supply 1-1,000 explicit public or user-authorized HTTPS URLs. HTML is capped at 5 MB, combined JSON-LD at 2 MB, script blocks at 100, entities at 500, JSON depth at 40, and supported claims at 5,000. Version 0.1 performs HTTP retrieval only and does not execute JavaScript.

### Output

One result row is written per input URL, followed by one uncharged run-summary row. A result preserves:

- source URL with query values redacted, retrieval status, content type, and raw SHA-256;
- per-script byte length, hash, parse status, entity count, and source locator;
- JSON-LD entity type/ID, supported claim value, JSON Pointer, comparison status, method, and visible evidence locators;
- parse errors without copying raw scripts;
- deterministic counts, verdict, logic version, and canonical result hash.

`aligned` means every comparable supported claim was corroborated and no script was malformed. `discrepancies_found` means a supported claim was not corroborated or a script was malformed. `no_comparable_claims` and `comparison_disabled` are explicit. `no_jsonld` is a terminal negative, not an error.

### Pricing and billing boundary

The pay-per-event event is `structured-evidence-audit` at **$0.05 per completed site audit**. Aligned pages, discrepancy reports, malformed JSON-LD reports, pages with no JSON-LD, and definitive 404/410 results are chargeable because the requested audit reached a durable terminal result. Unsafe URLs, duplicate inputs, transient failures, rate limits, unsupported content, parser resource-limit failures, internal failures, and charge-limit remainder rows are uncharged.

One URL costs up to $0.05 in Actor events; ten cost up to $0.50; one thousand cost up to $50.00, plus platform usage displayed by Apify. Chargeable rows use the SDK's combined dataset-push/event path, which persists each admitted dataset item before charging under one charge lock. The Actor never calls a standalone charge before output and stops scheduling after the event charge limit is reached.

### Determinism and provenance

The same HTML, base URL, options, and logic version produce the same audit payload and canonical hash. Retrieval timestamps and run IDs live outside the hashed audit data. The fixture manifest records bytes, SHA-256, source URL, license, and derivation; `evidence/fixture-audit-v1.json` is an exact expected artifact regenerated by tests.

### Safety, privacy, and source rights

Only explicit URLs are fetched. HTTPS, DNS, redirects, ports, userinfo, and public-IP resolution are enforced by the shared SSRF boundary. Page bodies and raw JSON-LD are not logged or redistributed. Query values are redacted from emitted URLs. The Actor has no telemetry or external database; Apify retention follows the customer's account settings. The controlled fixture is Flintglade-authored CC0 test infrastructure. Customers remain responsible for access authorization and downstream use.

### Limitations

AP-028 does not execute JavaScript, expand contexts, apply JSON-LD framing/compaction, validate every JSON-LD or Schema.org rule, infer hidden visual state, or decide whether a search engine will accept rich results. Exact normalized comparisons are intentionally conservative and may report `not_observable` when HTML has no field-specific evidence.

Emitted claim values are capped at 500 characters. Longer values retain a deterministic hash and `valueTruncated: true`; values over 2,000 characters are explicitly `not_compared` instead of being partially matched.

Support: `support@flintglade.com`. See `SOURCE_POLICY.md`, `THREAT_MODEL.md`, `LIVE_PROBES.md`, and `CHANGELOG.md`.

# Actor input Schema

## `inputSchemaVersion` (type: `integer`):

Versioned runtime input contract.

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

Public or user-authorized HTTPS HTML pages. Each completed page audit can create one event.

## `compareVisibleContent` (type: `boolean`):

Compare supported JSON-LD claims with deterministic HTML evidence. When false, syntax and structure are still audited.

## `maxHtmlBytes` (type: `integer`):

Oversized responses are rejected and uncharged.

## `maxJsonLdBytes` (type: `integer`):

Combined JSON-LD script limit per page. Limit failures are uncharged.

## `maxJsonLdScripts` (type: `integer`):

Maximum script blocks examined per page.

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

Bounded simultaneous page reads; it does not change the event price.

## Actor input object example

```json
{
  "inputSchemaVersion": 1,
  "urls": [
    "https://flintglade-tools.github.io/apify-fixtures/jsonld/product.html"
  ],
  "compareVisibleContent": true,
  "maxHtmlBytes": 2000000,
  "maxJsonLdBytes": 500000,
  "maxJsonLdScripts": 50,
  "concurrency": 8
}
```

# Actor output Schema

## `defaultDataset` (type: `string`):

Chargeable page-audit rows, uncharged failure rows, and the run summary.

## `runSummary` (type: `string`):

The final uncharged run-summary row in the default dataset.

# 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://flintglade-tools.github.io/apify-fixtures/jsonld/product.html"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("flintglade/jsonld-structured-evidence-auditor").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://flintglade-tools.github.io/apify-fixtures/jsonld/product.html"] }

# Run the Actor and wait for it to finish
run = client.actor("flintglade/jsonld-structured-evidence-auditor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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://flintglade-tools.github.io/apify-fixtures/jsonld/product.html"
  ]
}' |
apify call flintglade/jsonld-structured-evidence-auditor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=flintglade/jsonld-structured-evidence-auditor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "JSON-LD Structured Evidence Auditor",
        "description": "Audit JSON-LD claims against visible evidence on explicit authorized pages with bounded, provenance-rich output.",
        "version": "0.1",
        "x-build-id": "ntDmfRG3nXtQabCqs"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/flintglade~jsonld-structured-evidence-auditor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-flintglade-jsonld-structured-evidence-auditor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/flintglade~jsonld-structured-evidence-auditor/runs": {
            "post": {
                "operationId": "runs-sync-flintglade-jsonld-structured-evidence-auditor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/flintglade~jsonld-structured-evidence-auditor/run-sync": {
            "post": {
                "operationId": "run-sync-flintglade-jsonld-structured-evidence-auditor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "urls"
                ],
                "properties": {
                    "inputSchemaVersion": {
                        "title": "Input schema version",
                        "minimum": 1,
                        "maximum": 1,
                        "type": "integer",
                        "description": "Versioned runtime input contract.",
                        "default": 1
                    },
                    "urls": {
                        "title": "Explicit page URLs",
                        "minItems": 1,
                        "maxItems": 1000,
                        "type": "array",
                        "description": "Public or user-authorized HTTPS HTML pages. Each completed page audit can create one event.",
                        "items": {
                            "type": "string",
                            "maxLength": 2048
                        }
                    },
                    "compareVisibleContent": {
                        "title": "Compare visible content",
                        "type": "boolean",
                        "description": "Compare supported JSON-LD claims with deterministic HTML evidence. When false, syntax and structure are still audited.",
                        "default": true
                    },
                    "maxHtmlBytes": {
                        "title": "Maximum HTML bytes",
                        "minimum": 1024,
                        "maximum": 5000000,
                        "type": "integer",
                        "description": "Oversized responses are rejected and uncharged.",
                        "default": 2000000
                    },
                    "maxJsonLdBytes": {
                        "title": "Maximum JSON-LD bytes",
                        "minimum": 1024,
                        "maximum": 2000000,
                        "type": "integer",
                        "description": "Combined JSON-LD script limit per page. Limit failures are uncharged.",
                        "default": 500000
                    },
                    "maxJsonLdScripts": {
                        "title": "Maximum JSON-LD scripts",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum script blocks examined per page.",
                        "default": 50
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 16,
                        "type": "integer",
                        "description": "Bounded simultaneous page reads; it does not change the event price.",
                        "default": 8
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```