subimpact WhatsApp us

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.

from $0.0015 per page processed, $1.50 per 1,000 · Updated Nov 2026, version 0.1.18

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, version 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.

Output fields

FieldTypeDescription
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)
Show all 13 fields
FieldTypeDescription
error string/null Error message when status is error

Sample output

From one of our own test runs on 20 Nov 2026, trimmed. Personal data is redacted.

2 rows, first 3 shown

[
  {
    "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
  }
]

Input

FieldTypeRequiredDescriptionDefault
startUrls array Yes List of pages to extract JSON-LD from. Each entry: {"url": "https://..."} [{"url":"https://en.wikipedia.org/wiki/Artificial_intelligence"}]
validateSchema boolean No Check every @type and property against the bundled Schema.org ontology (979 types, 1,633 properties). Reports unknown types and invalid properties per page. true
resolveGraph boolean No 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. true
includeRawBlocks boolean No Also store the parsed JSON-LD blocks verbatim in each row (useful for debugging or downstream processing). false
maxChargeUsd number No Hard ceiling on what this run may charge. Once reached, no further events are billed. 5
maxPages integer No Hard limit on how many URLs this run may request. Leave empty for no limit. -
estimateOnly boolean No Run the full extraction and report what it would cost, without charging anything. false
proxyConfiguration object No Apify proxy for IP rotation. Leave default for automatic proxy. -

Example input

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

Pricing

EventWhat it meansPriceLowest tier
page-processed Per page with at least one JSON-LD block $0.0015 $0.0015
actor-start Once per run $0.00005 $0.00005

$1.50 for 1,000 page processed units at the listed price.

Prices from the Apify Store on 20 November 2026. 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. Every row is a live listing on the Store, read on 20 Nov 2026, so a buyer can check each number at the source.

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 Pay per event $1.50 $1.50 $0.00005 Paid separately 2 No reviews yet 18 Nov 2026
JSON-LD Schema & Meta Tag Extractor Direct match, pay per event $5.00 $3.50 None Included 51 No reviews yet 14 Nov 2026
JSON-LD & Schema.org Extractor Direct match, pay per event $1.00 $0.467 $0.01 Included 19 No reviews yet 19 Oct 2026
JSON-LD Extractor – Schema.org Data & Rich Snippets Direct match, pay per event Charges per entity item, so one page with many entities costs several items. $0.00005 Included 9 No reviews yet 15 Oct 2026
Schema Markup Extractor - JSON-LD SEO Data Direct match, pay per event $1.50 $1.20 $0.00005 Included 6 No reviews yet 29 Oct 2026
Schema Markup & JSON-LD Validator Partial match, pay per event $0.05 $0.05 None Included 16 No reviews yet 2 Aug 2026
Where JSON-LD Schema & Meta Tag Extractor is stronger

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

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

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

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

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.

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

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

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

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

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 above.

MCP users: @subimpact/data-mcp exposes these actors as tools, so an agent can call jsonld_entities directly.

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.

Questions people ask

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.

Need a data source that is not here?

We build and run scrapers for sites that have no public API. Tell us the site, the fields and how often you need them.