# JSON-LD Entity Graph Resolver

JSON-LD Entity Graph Resolver fetches a page, extracts its application/ld+json blocks, validates each @type and property against a bundled Schema.org ontology of 979 types and 1,633 properties, and merges disconnected blocks into one graph of nodes and typed edges resolved by @id. It costs $0.0015 per page with JSON-LD ($1.50 per 1,000 pages), first 3 pages free. Run it from the Apify Console, API or MCP.

## Key facts

- Price: from $0.0015 per page processed, $1.50 per 1,000
- Pricing model: Pay per event
- Output: JSON, CSV, Excel, XML, RSS via Apify datasets
- Access: Apify Console, REST API, Python and JS clients, MCP tool jsonld_entities
- Version: Updated Nov 2026, build 0.1.18
- Usage: 558 runs, 100.0% successful runs (30 days)
- Actor: subimpact/jsonld-entity-graph-resolver

## Who it is for

- SEO engineers auditing structured data across a large site
- Knowledge graph and RAG teams mapping entities from public pages
- Competitive analysts reading what schema a rival publishes
- Publishers checking schema drift after a CMS migration

## Use cases

### Audit schema across a site

Put a list of URLs in startUrls and run with validateSchema on. Each row returns block_count, types_found and a validation report listing unknown types and invalid properties per page. That is the same class of problem Google's Rich Results test flags, found in bulk across hundreds of templates before it costs you a rich result.

### Merge blocks into one entity graph

With resolveGraph on, the Actor flattens every typed node, indexes them by resolved @id, and walks properties so that reference strings and nested objects become edges. A WebSite block and a NewsMediaOrganization block linked by an @id fragment come back as two nodes joined by an edge, rather than two orphan schemas you have to reconcile yourself.

### Feed a knowledge graph or RAG index

Nodes carry an id, its types and its properties, and edges carry subject, predicate and object, so the output loads straight into a graph store instead of being re-parsed from HTML. Turn on includeRawBlocks when you want the original blocks alongside the graph for provenance, and use final_url to record where a redirect actually landed.

### Compare schemas against a competitor

Run the same Actor on your domain and on a competitor's key pages, then diff types_found and the @id targets in the graph. You see which entities they declare, how their publisher and author nodes connect, and which properties they publish that you do not, which is often the practical answer to why their listings show richer snippets.

### Estimate before you crawl

Set estimateOnly to true and the Actor performs the full extraction and reports what the run would cost without charging. Pages with no JSON-LD are free anyway. Pair that with maxChargeUsd and maxPages to keep a crawl of a large domain inside a fixed budget, which matters when you point a new URL list at 50,000 pages.

## Price events

- Page processed (`page-processed`): $0.0015, lowest tier $0.0015. Per page with at least one JSON-LD block
- Actor start (`actor-start`): $0.00005, lowest tier $0.00005. Once per run

Prices from the Apify Store. Apify shows the final price before each run.

## How it compares with other Apify actors

Price per 1,000 pages at Apify Store list prices, checked 20 Nov 2026.

| Actor | Price per 1,000 pages (Free plan) | Higher plans (Gold) | Start fee per run | Platform usage | Users | Rating | Last build |
| --- | --- | --- | --- | --- | --- | --- | --- |
| JSON-LD Entity Graph Resolver — Schema.org to Knowledge Graph (this API) | $1.50 | $1.50 | $0.00005 | Paid separately | 2 | No reviews yet | 18 Nov 2026 |
| [JSON-LD Schema & Meta Tag Extractor](https://apify.com/logiover/json-ld-schema-meta-tag-extractor) | $5.00 | $3.50 | None | Included | 51 | No reviews yet | 14 Nov 2026 |
| [JSON-LD & Schema.org Extractor](https://apify.com/andok/jsonld-extractor) | $1.00 | $0.467 | $0.01 | Included | 19 | No reviews yet | 19 Oct 2026 |
| [JSON-LD Extractor – Schema.org Data & Rich Snippets](https://apify.com/ninhothedev/json-ld-extractor) | Charges per entity item, so one page with many entities costs several items. | Same unit, see the first price column | $0.00005 | Included | 9 | No reviews yet | 15 Oct 2026 |
| [Schema Markup Extractor - JSON-LD SEO Data](https://apify.com/benthepythondev/schema-markup-extractor) | $1.50 | $1.20 | $0.00005 | Included | 6 | No reviews yet | 29 Oct 2026 |
| [Schema Markup & JSON-LD Validator](https://apify.com/maximedupre/schema-markup-validator) | $0.05 | $0.05 | None | Included | 16 | No reviews yet | 2 Aug 2026 |

### Where JSON-LD Schema & Meta Tag Extractor is stronger

- Also extracts Open Graph and Twitter Card tags alongside JSON-LD
- Output includes page title, meta description and canonical URL

### Where this API is stronger

- Merges disconnected blocks into one graph with resolved id edges
- Validates each node against the bundled Schema.org ontology
- Output records block, node and edge counts for each page

### Where JSON-LD & Schema.org Extractor is stronger

- Very light input, just URLs with timeout and concurrency controls
- Reports parse errors for each URL checked

### Where this API is stronger

- Returns the resolved graph with typed edges, not block counts alone
- Validation covers both Schema.org types and properties
- Raw JSON-LD blocks can be kept alongside the resolved graph

### Where JSON-LD Extractor – Schema.org Data & Rich Snippets is stronger

- Returns one row per entity with an entity id and schema type
- Can include microdata alongside JSON-LD in the same run

### Where this API is stronger

- Charges per page processed, so a page with many entities costs the same
- Disconnected blocks are merged into a single graph with typed edges
- Each node is validated against Schema.org types and properties

### Where Schema Markup Extractor - JSON-LD SEO Data is stronger

- Accepts a sitemap URL, so a whole site can be queued from one field
- Output lists which markup formats were found on each page

### Where this API is stronger

- Resolves blocks into a unified graph rather than per page counts alone
- Validation checks Schema.org types and properties, with raw blocks available
- A maximum charge input caps spend before a run proceeds

### Where Schema Markup & JSON-LD Validator is stronger

- Audits microdata and RDFa as well as JSON-LD
- Returns issue details and rich result readiness signals per page
- Can crawl several pages from the start URLs you give it

### Where this API is stronger

- Merges disconnected blocks into one graph with resolved id edges
- Validation runs against a bundled Schema.org ontology
- Output gives block, node and edge counts for sizing a graph quickly

These actors all read JSON-LD from public pages, and most return one row per URL. The difference is what happens after extraction: several of them report counts, parse errors or rich result signals, while this actor merges blocks into a single validated graph. Buyers auditing markup for rich results may prefer the validator style actors, and graph builders will prefer this one.

Prices are Apify Store list prices, checked 20 Nov 2026. Platform usage 'Paid separately' means Apify bills compute on top of the event price. Check each listing before you buy.

## Input

- `startUrls` (array, required): List of pages to extract JSON-LD from. Each entry: {"url": "https://..."}
- `validateSchema` (boolean, optional): Check every @type and property against the bundled Schema.org ontology (979 types, 1,633 properties). Reports unknown types and invalid properties per page.
- `resolveGraph` (boolean, optional): Resolve @id references across all blocks on the page and emit a unified graph: nodes (id, types, properties) + edges (subject, predicate, object). Disconnected schemas become one graph.
- `includeRawBlocks` (boolean, optional): Also store the parsed JSON-LD blocks verbatim in each row (useful for debugging or downstream processing).
- `maxChargeUsd` (number, optional): Hard ceiling on what this run may charge. Once reached, no further events are billed.
- `maxPages` (integer, optional): Hard limit on how many URLs this run may request. Leave empty for no limit.
- `estimateOnly` (boolean, optional): Run the full extraction and report what it would cost, without charging anything.
- `proxyConfiguration` (object, optional): Apify proxy for IP rotation. Leave default for automatic proxy.

### Example input

```json
{
  "startUrls": [
    {
      "url": "https://en.wikipedia.org/wiki/Artificial_intelligence"
    },
    {
      "url": "https://www.nytimes.com/"
    }
  ]
}
```

## Output fields

- `url` (string): The requested URL
- `final_url` (string/null): URL after redirects
- `content_type` (string/null): Content-Type header of the response
- `status` (string): success | no-jsonld | error
- `http_status` (integer/null): HTTP status code of the fetch
- `block_count` (integer): Number of JSON-LD blocks found on the page
- `node_count` (integer): Number of typed nodes in the resolved graph
- `edge_count` (integer): Number of edges in the resolved graph
- `types_found` (array/null): Valid schema.org types found on the page
- `validation` (object/null): Schema.org validation: valid/unknown types, invalid properties
- `graph` (object/null): Unified graph: nodes + edges with resolved @id references
- `raw_blocks` (array/null): Parsed JSON-LD blocks verbatim (only present when includeRawBlocks is true)
- `error` (string/null): Error message when status is error

## Sample output

Trimmed from one of our own test runs. Personal data is redacted.

```json
[
  {
    "url": "https://en.wikipedia.org/wiki/Artificial_intelligence",
    "status": "success",
    "http_status": 200,
    "final_url": "https://en.wikipedia.org/wiki/Artificial_intelligence",
    "content_type": "text/html; charset=UTF-8",
    "block_count": 1,
    "node_count": 4,
    "edge_count": 7,
    "types_found": [
      "Article"
    ],
    "validation": {
      "node_count": 1,
      "valid_types": [
        "Article"
      ],
      "unknown_types": [],
      "invalid_properties": [],
      "valid_type_count": 1,
      "unknown_type_count": 0,
      "invalid_property_count": 0,
      "ancestors": {
        "Article": [
          "CreativeWork",
          "Thing"
        ]
      }
    },
    "graph": {
      "@context": "https://schema.org",
      "pageUrl": "https://en.wikipedia.org/wiki/Artificial_intelligence",
      "nodes": [
        {
          "@id": "_:b1",
          "@type": [
            "Article"
          ],
          "properties": "{...}",
          "source_block": 0
        },
        {
          "@id": "_:b2",
          "@type": [
            "Organization"
          ],
          "properties": "{...}",
          "source_block": 0
        },
        {
          "@id": "_:b3",
          "@type": [
            "Organization"
          ],
          "properties": "{...}",
          "source_block": 0
        },
        "..."
      ],
      "edges": [
        {
          "subject": "_:b1",
          "predicate": "url",
          "object": "https://en.wikipedia.org/wiki/Artificial_intelligence"
        },
        {
          "subject": "_:b1",
          "predicate": "sameAs",
          "object": "http://www.wikidata.org/entity/Q11660"
        },
        {
          "subject": "_:b1",
          "predicate": "mainEntity",
          "object": "http://www.wikidata.org/entity/Q11660"
        },
        "..."
      ]
    },
    "raw_blocks": null,
    "error": null
  },
  {
    "url": "https://www.nytimes.com/",
    "status": "success",
    "http_status": 200,
    "final_url": "https://www.nytimes.com/",
    "content_type": "text/html; charset=utf-8",
    "block_count": 2,
    "node_count": 53,
    "edge_count": 133,
    "types_found": [
      "WebSite",
      "NewsMediaOrganization"
    ],
    "validation": {
      "node_count": 2,
      "valid_types": [
        "WebSite",
        "NewsMediaOrganization"
      ],
      "unknown_types": [],
      "invalid_properties": [],
      "valid_type_count": 2,
      "unknown_type_count": 0,
      "invalid_property_count": 0,
      "ancestors": {
        "WebSite": [
          "CreativeWork",
          "Thing"
        ],
        "NewsMediaOrganization": [
          "Organization",
          "Thing"
        ]
      }
    },
    "graph": {
      "@context": "https://schema.org",
      "pageUrl": "https://www.nytimes.com/",
      "nodes": [
        {
          "@id": "_:b1",
          "@type": [
            "WebSite"
          ],
          "properties": "{...}",
          "source_block": 0
        },
        {
          "@id": "_:b2",
          "@type": [
            "ImageObject"
          ],
          "properties": "{...}",
          "source_block": 0
        },
        {
          "@id": "_:b3",
          "@type": [
            "ImageObject"
          ],
          "properties": "{...}",
          "source_block": 0
        },
        "..."
      ],
      "edges": [
        {
          "subject": "_:b1",
          "predicate": "image",
          "object": "_:b2"
        },
        {
          "subject": "_:b2",
          "predicate": "url",
          "object": "https://static01.nyt.com/vi-assets/images/share/1200x675_nameplate.png"
        },
        {
          "subject": "_:b2",
          "predicate": "contentUrl",
          "object": "https://static01.nyt.com/vi-assets/images/share/1200x675_nameplate.png"
        },
        "..."
      ]
    },
    "raw_blocks": null,
    "error": null
  }
]
```

## How to run it

1. Add pages to startUrls, for example [{"url": "https://www.nytimes.com/"}]; each entry takes the object form with a url key.
2. Leave validateSchema and resolveGraph on; they are enabled by default and produce the validation report and the graph.
3. Set maxChargeUsd and maxPages for a large crawl, or run once with estimateOnly to see the cost first.
4. Start the run in the Apify Console; each page produces a row with block_count, types_found, validation and graph.
5. Read nodes and edges from the graph object, or export the dataset as JSON, CSV or Excel.

### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/subimpact~jsonld-entity-graph-resolver/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrls":[{"url":"https://en.wikipedia.org/wiki/Artificial_intelligence"},{"url":"https://www.nytimes.com/"}]}'
```

### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("subimpact/jsonld-entity-graph-resolver").call(run_input={
      "startUrls": [
        {
          "url": "https://en.wikipedia.org/wiki/Artificial_intelligence"
        },
        {
          "url": "https://www.nytimes.com/"
        }
      ]
    })

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

### JavaScript

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('subimpact/jsonld-entity-graph-resolver').call({
  "startUrls": [
    {
      "url": "https://en.wikipedia.org/wiki/Artificial_intelligence"
    },
    {
      "url": "https://www.nytimes.com/"
    }
  ]
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();

console.log(items);
```

### MCP

```bash
claude mcp add subimpact-data -e APIFY_TOKEN=<YOUR_APIFY_TOKEN> -- npx -y @subimpact/data-mcp

# Then ask your agent to use the jsonld_entities tool.
```

### n8n

Use the Apify node (Run an Actor).
Actor ID: subimpact/jsonld-entity-graph-resolver
Input JSON: paste the example input below.

## Limits

- Hard caps of 50 JSON-LD blocks, 500 nodes and 2,000 edges per page.
- Pages are limited to 4 MB and a 25 second fetch timeout.
- Malformed JSON-LD blocks are skipped silently rather than reported.
- Pages behind a WAF or bot wall may need a browser-based actor instead.

## FAQ

### What does a page cost?

$0.0015 for a page that contains at least one JSON-LD block, which is $1.50 per 1,000 pages, plus a $0.00005 Actor start event. The first 3 pages of each run are free, and pages with no JSON-LD are free, so a crawl of mostly static pages is cheap.

### Does it need a browser or an API key?

Neither. JSON-LD is server-rendered by definition, so the Actor uses a plain HTTP fetch with no Playwright and no LLM. The Schema.org ontology is bundled in the image, so validation makes no network calls at runtime and needs no key.

### What exactly is in the graph output?

nodes, each with an id, its types and its properties, and edges, each with subject, predicate and object. Every typed node from every block is flattened, indexed by resolved @id, and its references turned into edges. @id resolution handles absolute URLs, protocol-relative hosts, root paths, fragments and relative paths.

### Does a validation error fail the run?

No. Unknown types and invalid properties are reported per page as signals, not errors, because they often mean a custom vocabulary, a vendor extension or a typo. The row still returns its blocks, types and graph, and the job continues to the next URL.

### How much can one page return?

Up to 50 JSON-LD blocks, 500 nodes and 2,000 edges per page, and a page of up to 4 MB within a 25 second fetch timeout. Those are hard caps, so a page that legitimately carries more is truncated at that point.

### Can I cap the spend of a large crawl?

Yes. maxChargeUsd is a hard ceiling on what the run may charge, and once it is reached no further events are billed. maxPages caps how many URLs are requested, and estimateOnly reports the cost of a full run without charging anything.

### What happens with broken JSON-LD?

Malformed blocks are skipped silently, which is common in the wild. The parser is tolerant of HTML entities, trailing commas, a BOM, CDATA and comment wrappers, and @graph containers, so a block that is broken only by one of those still comes through.

## Links

- Page: https://subimpact.net/apis/jsonld-entity-graph-resolver/
- Category: https://subimpact.net/apis/category/search-seo/
- Run on Apify: https://apify.com/subimpact/jsonld-entity-graph-resolver
- All data APIs: https://subimpact.net/apis/
- Catalogue JSON: https://subimpact.net/apis/catalogue.json
