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 and fragments.)
• 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.010 (once per run)
Page processed	$0.003 (only pages with ≥1 JSON-LD block)
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.

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
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, @graph containers.
• @id resolution handles absolute URLs, //host, /root, #fragment, and relative paths.