JSON-LD Entity Graph Resolver

Crawls web pages, extracts deeply nested JSON-LD schema blocks, validates them against the Schema.org ontology (979 types, 1,633 properties, full hierarchy), and maps disconnected schemas into a clean, unified knowledge graph — nodes with resolved @id references plus typed edges.

No browser, no API keys, no LLM. JSON-LD is server-rendered by definition, so this actor uses a plain HTTP fetch — 10× cheaper than browser-based extractors in the same lane.

What you get per page

Field	Description
block_count	Number of <script type="application/ld+json"> blocks found
types_found	Valid schema.org types on the page (e.g. Article, Organization, Product)
validation	Per-page report: valid types, unknown types, invalid properties
graph	Unified knowledge graph: nodes (id, types, properties) + edges (subject, predicate, object)
raw_blocks	Parsed JSON-LD blocks verbatim (opt-in)

The graph resolver

Most pages ship multiple disconnected JSON-LD blocks — a WebSite block, a NewsMediaOrganization block, an Article block — often referencing each other by @id fragments (#publisher) or absolute URLs. This actor:

1. Flattens every typed node from every block.
2. Indexes nodes by resolved @id (fragments resolve against the page URL).
3. Walks every property; reference strings and nested typed objects become edges.
4. Emits one unified graph: {"@context": "https://schema.org", "pageUrl": ..., "nodes": [...], "edges": [...]}.

Example — NYT homepage: the WebSite block and the NewsMediaOrganization block (@id: https://www.nytimes.com/#publisher) become two nodes joined by an edge, instead of two orphan schemas.

Validation

The bundled Schema.org snapshot (from the official schema.org release) powers:

• Type validation — is @type a real schema.org class? (Handles schema: prefixes, fragments, and full https://schema.org/... IRIs.)
• Property validation — are the node's properties real schema.org properties?
• Hierarchy — every type's ancestors up to Thing are available for downstream reasoning.

Unknown types and invalid properties are reported per page — they are not errors, just signals (custom vocabularies, typos, or vendor extensions).

Pricing

Pay per event, usage billed to you:

Event	Price
Actor start	$0.00005 (once per run; waived entirely when the whole run stays within the 3 free pages)
Page processed	$0.0015 (only pages with ≥1 JSON-LD block); $1.50 per 1,000 pages
Pages with no JSON-LD	Free

First 3 pages per run are free. maxChargeUsd caps the run's total charge; estimateOnly runs the full extraction and reports cost without charging.

How this compares

The actor resolves JSON-LD over a plain HTTP fetch, with no browser and no API key, so the platform usage you pay for a run is small. It also does more than extract blocks: every node is validated against the bundled Schema.org ontology and disconnected blocks are merged into one graph with resolved @id edges. At $1.50 per 1,000 pages it is below logiover/json-ld-schema-meta-tag-extractor ($5.00), mahogany_songbird/schema-local-business-parser ($2.00) and webdatatools/structured-data-extractor ($2.00). andok/jsonld-extractor ($1.00) and ninhothedev/json-ld-extractor ($0.50) list a lower per-result price; andok/jsonld-extractor also charges a $0.01 actor-start event on the Free plan.

Actor	Price per 1,000 pages	Platform usage
subimpact/jsonld-entity-graph-resolver	$1.50	paid by you
logiover/json-ld-schema-meta-tag-extractor	$5.00	see listing
webdatatools/structured-data-extractor	$2.00	see listing
mahogany_songbird/schema-local-business-parser	$2.00	see listing
ninhothedev/json-ld-extractor	$0.50	see listing

Prices are Apify Store list prices on the Free plan, checked 24 October 2026. Competitor prices can change; check their listings.

Input

Field	Type	Default	Description
startUrls	array	—	Pages to extract from. [{"url": "https://..."}]
validateSchema	boolean	true	Validate types/properties against Schema.org
resolveGraph	boolean	true	Build the unified knowledge graph
includeRawBlocks	boolean	false	Include parsed JSON-LD blocks verbatim
maxChargeUsd	number	5.0	Hard cap on total charge per run
maxPages	integer	— (empty = no limit)	Optional hard cap on how many URLs are requested
estimateOnly	boolean	false	Dry run — report cost, charge nothing
proxyConfiguration	object	auto	Apify proxy for IP rotation

Use cases

• SEO / structured-data QA — validate schema markup across a site, find unknown types and invalid properties before Google's Rich Results tester does.
• Entity extraction for RAG / knowledge graphs — turn a page's disconnected schemas into one queryable graph.
• Competitive schema intelligence — what entities does a competitor's site declare? (Types, @id targets, publisher/author graphs.)
• Schema drift monitoring — track types_found and validation reports over time.

Limits

• 50 JSON-LD blocks / 500 nodes / 2,000 edges per page (hard caps).
• 4 MB max page size, 25 s fetch timeout.
• Malformed JSON-LD blocks are skipped silently (common in the wild).
• Pages behind WAFs / bot walls may need the Apify proxy or a browser-based actor.

Tech notes

• Plain HTTP fetch (urllib) — no Playwright, no browser, no LLM.
• Schema.org ontology bundled in the image (no network calls at runtime).
• Tolerant parser: HTML entities, trailing commas, BOM, CDATA/comment wrappers, @graph containers.
• @id resolution handles absolute URLs, //host, /root, #fragment, and relative paths.