Pricing

$3.00 / 1,000 analysed pages

Try for free

Go to Apify Store

Structured Data Extractor

Try for free

JSON-LD, microdata, RDFa Lite, Open Graph, Twitter Card, meta, hreflang and canonical for a list of URLs, with SEO validation flags, in one call.

Pricing

$3.00 / 1,000 analysed pages

Rating

0.0

(0)

Developer

openrows

Actor stats

Bookmarked

Total users

Monthly active users

a day ago

Last modified

What data you get

For every page the Actor returns:

Field	Description
`url`	Page the result was extracted from
`scrapedAt`	ISO 8601 timestamp of the extraction
`jsonLd`	Every JSON-LD entity found, flattened out of any `@graph` wrapper, each keeping its `@type`
`microdata`	Top-level `itemscope` items (HTML microdata), each with its `itemtype`(s), `itemid` and properties
`rdfa`	Top-level `[typeof]` items (RDFa Lite), each with its type(s), `resource` and properties
`openGraph`	`og:*` meta properties, keyed without the `og:` prefix
`twitter`	`twitter:` meta tags, keyed without the `twitter:` prefix (`creator`/`site` and every `label`/`data*` pair are dropped — see below)
`meta`	`title`, `description`, `robots`, `viewport`, `charset` from `<head>`
`hreflang`	`<link rel="alternate" hreflang>` entries, with absolute URLs
`canonical`	`<link rel="canonical">` target, resolved to an absolute URL, or `null`
`validation`	Missing required properties for recognised `@type`s — see "Validation rules" below
`raw`	Only when `includeRaw` is true: each JSON-LD block in its original, unflattened shape

Input

Option	Type	Default	Description
`urls`	array	-	Pages to extract structured data from. Required.
`maxItems`	integer	`100`	Stop after this many results (max 10,000). Also your cost cap.
`includeRaw`	boolean	`false`	Also return each page's JSON-LD blocks in their original, unflattened shape.
`proxyConfiguration`	object	Apify datacenter	Proxy settings

Example input:

{
    "urls": ["https://docs.apify.com/", "https://schema.org/Product"],
    "maxItems": 50
}

Output example

{
    "url": "https://schema.org/Product",
    "scrapedAt": "2026-09-22T10:15:30.000Z",
    "jsonLd": [{ "@type": "WebPage", "name": "Product - Schema.org Type" }],
    "microdata": [],
    "rdfa": [],
    "openGraph": {},
    "twitter": {},
    "meta": {
        "title": "Product - Schema.org Type",
        "description": null,
        "robots": null,
        "viewport": null,
        "charset": "UTF-8"
    },
    "hreflang": [],
    "canonical": null,
    "validation": []
}

A run summary (items pushed, items skipped by category, pages fetched, failed requests by category, stop reason) is stored in the run's key-value store under the key OUTPUT.

Validation rules

A simple, documented rule set — not a full schema.org or Google Rich Results validator. For entities whose type matches one of the rows below (checked on both jsonLd and microdata; rdfa is not checked), the Actor flags which of the listed properties are missing. A type not in this list is not checked at all, and a matching entity with nothing missing produces no entry in validation[].

Type (any of)	Required properties checked
`Product`	`name`, `image`, `description`, `offers`
`Article`, `NewsArticle`, `BlogPosting`	`headline`, `image`, `datePublished`
`Organization`	`name`, `url`
`BreadcrumbList`	`itemListElement`

author/creator are intentionally absent from every row: this Actor drops those properties for privacy before validation ever runs (see "Data and compliance"), so requiring them would flag a page as broken for a field it never had a chance to keep.

Pricing

Pay per result. You are charged per result and nothing else: no platform usage, no compute units. Listing pages, retries and failed requests are free. The current rate is on the Pricing tab of this Actor — that is the only place it is set, so no figure is repeated here.

maxItems caps the number of results, and therefore the cost, of a run.
The run also stops when it reaches the maximum total charge you set for the run in Apify Console or through the API.

Tips

Start with maxItems: 20 to check the fields before a large run.
If you only need the source's own @graph grouping rather than this Actor's flattened jsonLd[] list, set includeRaw: true and read raw.jsonLdBlocks.

Limitations

Pages that require a login, or that build their structured data with client-side JavaScript after load, are not accessible to an HTTP-only fetch and are not scraped — you'll get an empty result, not an error.
microdata and rdfa do not support itemref/indirect property references (properties pulled in from elsewhere in the document by id) — only directly nested properties are read. Uncommon in practice; every page seen while building this Actor used direct nesting.
openGraph covers the og: namespace only, not Facebook's wider article:/profile: namespaces (which can themselves carry personal fields like article:author or profile:first_name).
rdfa picks up any [typeof] attribute, including non-schema.org uses of the same mechanism (for example, MediaWiki sites annotate their own templates with a mw: namespace via typeof). These are harmless but not useful signal — filter by type prefix if your source does this.
validation covers four common types with a fixed property list each; it is not a general schema.org or Google Rich Results validator.

Data and compliance

This Actor is site-agnostic: it fetches only the URLs you give it, and does not discover, crawl or follow links beyond them. You choose the sources and are responsible for them — for your right to use the pages you point this Actor at, and for how you use the results.

This Actor collects publicly available, non-personal data only:

It fetches pages that are reachable without logging in and does not bypass access controls or solve CAPTCHAs.
It identifies itself with a plain openrows/structured-data-extractor User-Agent and sends no headers that imitate a browser.
It removes fields that identify a person before a result is stored:
- any JSON-LD, microdata or RDFa entity whose type is (or includes) Person — matched whether the type is given as a bare term, a prefixed name or a full IRI, with or without a trailing slash;
- the properties author, creator, byline, contributor, dc:creator, email, telephone, tel, wherever they appear in JSON-LD, microdata or RDFa;
- the Twitter Card twitter:creator and twitter:site handles, and every twitter:label* / twitter:data* pair — including the bare, unnumbered twitter:label / twitter:data form (free-form slots some sites use for a byline or reading time; the label text is caller-controlled, so these are dropped by key pattern regardless of what they say). creator/site are user handles, and this Actor does not try to guess which handles belong to an organisation rather than a person, so both are dropped rather than heuristically kept.
Credit fields are kept as public professional attribution. A developer, publisher, editor or holder name is kept exactly as the source page shows it — the same way a book cover credits its author, or software credits its publisher. This does not weaken the removal above: an entity that is itself Person-typed is still dropped even when it fills a credit field, and author/creator/ byline/contributor/email/telephone are still dropped wherever they appear.
Free text a page displays in its own right — a product name, an article headline, a description — is not personal data merely for being prose, and passes through unless its property name matches the list above. This also means a byline can reach the output through free text the property-name filter does not scan: for example, a page's own text-style free-text property (as in some of schema.org's microdata examples) can contain prose like "...by John Doe". This Actor does not scan free-text values for embedded names — doing so would mean guessing at what is a name inside arbitrary prose, which this Actor does not attempt (see the credit-fields point above). That text passes through as the buyer's content, same as any other free text on the page.

How robots.txt is handled

Before the first page on a host is fetched, the Actor fetches that host's robots.txt once and obeys it for the rest of the run. Rules are read for the product token openrows, falling back to the * group when the file does not name us, with * and $ wildcards and the standard "longest matching rule wins" precedence. A Crawl-delay set for us is honoured, up to 10 seconds. When a page redirects, the URL the redirect actually leads to is checked again against its own host's rules before anything is read from it, so a redirect cannot carry the Actor onto a site, or a path, that its owner puts off limits.

Disallowed URLs are never requested. They are reported under skipped.robotsDisallowed in the run summary, so you can see exactly how many of your input URLs the site puts off limits.
No robots.txt (404 or 410) means no rules, and the host is crawled normally. It is counted as robotsAbsent in the summary.
A robots.txt we cannot read means the host is skipped, not crawled. Any other response — 401, 403, 429, a 5xx, a timeout, a network failure, or a 200 that turns out to be an error or login page — leaves us without the site's rules, and this Actor will not guess. Every URL on that host is skipped and counted under skipped.robotsUnknown, and the host and the status that stopped us are listed under robots.unknownHosts in the summary. If a host you supplied returns no results, look there first.

Removal requests. If you believe this Actor exposes data it should not, open an issue on the Actor's Issues tab and state the URL(s) concerned. Requests are answered there, and the fields or pages in question are removed.

You are responsible for using the extracted data in line with the terms of the sites you point this Actor at and the laws that apply to you.

Support

Report bugs and request fields on the Issues tab of this Actor. Include the run ID.

Structured Data Scraper (Schema.org)

datavault/schemaorg

Fast, lightweight scraper that extracts structured data (JSON-LD & microdata) from HTML pages. Ideal for e-commerce and sites that embed schema.org markup without heavy client-side rendering.

Datavault

Structured Business Data Extractor

motivational_nickel/motivational-nickel-business-leads-extractor

Extracts structured business information from company websites for research and data enrichment. Converts public website content into clean, machine-readable data such as company name, contact details, and metadata. Intended for research, CRM enrichment, and company profiling. No outreach.

Leoncio Coronado Jr

Structured Data Scraper & Validator

taroyamada/structured-data-validator

Try Input: 1 URL ≈ USD 0.01 total. From USD 0.01 total. Paste URL and Start.

naoki anzai

Structured Data Extractor - JSON-LD, Microdata & RDFa

scrappy_garden/structured-data-extractor

Extract and validate structured data from any web page for SEO. Parses JSON-LD, detects Microdata and RDFa, highlights schema.org types, and reports common markup issues.

Bikram Adhikari

Structured Data Extractor - JSON-LD, OpenGraph, Meta

piposlab/structured-data-extractor

Extract JSON-LD, OpenGraph, Twitter cards, microdata and meta tags from any URL. For SEO audits, AI dataset building and competitor research. No API key.

Alejandro Bufarini

Structured Data Extractor

zinin/structured-extract

Extract title, meta, JSON-LD, headings, links, emails, and price observations from up to 100 authorized public static HTML pages. Delivered rows include source identity, selected fields, confidence, gaps, next action, retry status, and billing. No browser or LLM inference; non-delivery is free.

Tim Zinin

Structured Data Extractor — JSON-LD, Microdata, RDFa

q_services/structured-data-extractor

Extract schema.org structured data (JSON-LD, Microdata, RDFa) from any URLs. Clean output for SEO audits and AI data pipelines.

Q Services

Structured Data Extractor — URL to JSON

shelvick/structured-extractor

Extract structured data from a batch of URLs as schema-validated JSON. Send web pages and a JSON Schema; it scrapes each (stealth + residential proxy as needed), runs an LLM to convert the page to JSON matching your schema, and validates per URL. Omit schema for best-effort. Public pages only.

Scott Helvick

LangExtract - Structured Data Extractor

vivianferreira/langextract-structured-data-extractor

Extract structured data from unstructured text using Google's LangExtract library & LLMs. Get entities, relationships & attributes in clean JSON with source grounding. Supports Gemini, OpenAI, Anthropic, Groq & custom endpoints. Perfect for parsing resumes, contracts, reports & documents.

Vivian Ferreira

Web Structured Data Extractor (Claude, JSON Schema)

gochujang/web-structured-extractor

Pass a URL + JSON schema (or natural-language goal). Claude reads the page and returns a strict JSON object matching your schema. Product / news / hotel / real-estate / job-board extraction. BYO Anthropic API key. $0.01 per page.

Hojun Lee

Structured Data Extractor - JSON-LD, OpenGraph, Microdata

gratifying_graph/structured-data-extractor

Extract every piece of structured data from any URL: JSON-LD blocks by schema.org type, OpenGraph and Twitter Card tags, microdata items, canonical and meta basics. Batch over URL lists or call synchronously from AI agents.