Schema.org JSON-LD Generator

Create reusable structured-data blocks from details you already have. This schema.org JSON-LD generator converts business, product, article, event, FAQ, breadcrumb, organization, and webpage records into normalized JSON-LD, validates the minimum fields, and explains what to fix.

Each input entity produces one dataset result containing:

• a validation status;
• blocking errors;
• actionable quality warnings;
• normalized source details;
• a JSON-LD object and formatted JSON string; and
• an optional HTML <script type="application/ld+json"> block.

No page scraping, browser, login, proxy, or external AI service is involved. That makes repeated publishing runs deterministic and keeps supplied content inside the Actor run and its Apify storage.

What does this Actor do?

The Actor turns structured details into Schema.org markup suitable for a CMS, static-site build, spreadsheet automation, or SEO publishing pipeline.

It does more than interpolate a template. Before generating markup it:

1. trims whitespace recursively;
2. normalizes absolute URLs;
3. converts parseable date-times to ISO 8601;
4. uppercases currency codes;
5. checks required fields by schema type;
6. validates URL and date shapes;
7. maps FAQ entries to Question and Answer objects;
8. maps breadcrumbs to ordered ListItem objects; and
9. returns recommendations for stronger markup.

If an item has blocking errors, the result is retained for diagnosis but its jsonLd, jsonLdString, and scriptTag are null. The Actor never presents known-invalid input as deployable markup.

Who is it for?

• SEO teams generating structured data for many landing pages.
• Content publishers adding Article, FAQ, and breadcrumb blocks to a CMS.
• E-commerce teams preparing Product and Offer markup from catalog rows.
• Local marketers creating LocalBusiness blocks from approved business data.
• Developers validating structured fields during a deployment pipeline.
• Agencies producing consistent deliverables for multiple client sites.

Choose this Actor when the source details are already available. It does not crawl a URL to infer missing content.

Why use it?

A hand-built JSON template can silently preserve whitespace, malformed URLs, invalid dates, missing rich-result fields, or the wrong nested shape. This Actor gives each supplied entity an explicit outcome that can be filtered, reviewed, compared between runs, and sent to another automation.

Useful differentiators include:

• eight supported Schema.org types in one batch;
• stable caller-provided record IDs;
• typed dataset rows instead of one opaque file;
• invalid results alongside valid results for complete batch accounting;
• ready-to-paste script blocks;
• no third-party API key; and
• a bounded 1,000-item input contract.

Supported Schema.org types

Input type	Minimum fields	Helpful fields
LocalBusiness	name, address	url, telephone, openingHours
Product	name	description, image, offers
Article	headline, datePublished, author	image, publisher, mainEntityOfPage
Event	name, startDate, location	description, endDate, offers
FAQPage	questions	complete question-and-answer pairs
BreadcrumbList	items	complete name-and-URL pairs
Organization	name	url, logo
WebPage	name, url	description, dateModified

The checks are practical publishing safeguards, not a guarantee that a search engine will show a rich result. Search engines apply their own policies and may require additional properties for a particular feature.

Input parameters

Field	Type	Default	Description
items	array	required	One to 1,000 { id?, type, data } entities.
maxItems	integer	100	Process at most this many entities, from the start of the array.
includeScriptTag	boolean	true	Include a ready-to-paste HTML script block for valid items.

id is optional. When omitted, the Actor emits item-1, item-2, and so on. Use stable IDs in recurring runs so downstream systems can upsert or compare results reliably.

The data object contains ordinary Schema.org properties. Fields not involved in special FAQ or breadcrumb mapping are preserved after recursive normalization.

Getting started

1. Open the Actor input editor.
2. Add one or more entries to items.
3. Select one of the eight exact schema type names.
4. Put the entity details in data.
5. Keep includeScriptTag enabled when the result will be pasted into HTML.
6. Set maxItems to a small value for a trial run.
7. Start the run.
8. Open the Generated markup dataset view.
9. Filter isValid = false and correct blocking errors.
10. Review warnings before publishing valid script blocks.

A minimal Organization request is:

{
  "items": [
    {
      "id": "apify-organization",
      "type": "Organization",
      "data": {
        "name": "Apify",
        "url": "https://apify.com/",
        "logo": "https://apify.com/ext/apify-logo.svg"
      }
    }
  ]
}

Output fields

Field	Meaning
recordId	Supplied stable ID, or generated batch-position ID.
schemaType	Requested Schema.org type.
status	valid, valid_with_warnings, or invalid.
isValid	Whether reusable markup was generated.
errors	Blocking field, URL, date, or nested-item problems.
warnings	Suggested additions that can strengthen the markup.
normalizedInput	Cleaned details used to build the output.
jsonLd	Generated object, or null for invalid input.
jsonLdString	Pretty-printed JSON, or null.
scriptTag	Optional ready-to-paste HTML, or null.
generatedAt	ISO 8601 generation timestamp.

A real Organization result has this shape:

{
  "recordId": "apify-organization",
  "schemaType": "Organization",
  "status": "valid",
  "isValid": true,
  "errors": [],
  "warnings": [],
  "normalizedInput": {
    "name": "Apify",
    "url": "https://apify.com/",
    "logo": "https://apify.com/ext/apify-logo.svg"
  },
  "jsonLd": {
    "@context": "https://schema.org",
    "@type": "Organization",
    "name": "Apify",
    "url": "https://apify.com/",
    "logo": "https://apify.com/ext/apify-logo.svg"
  },
  "jsonLdString": "{\n  \"@context\": \"https://schema.org\",\n  \"@type\": \"Organization\",\n  \"name\": \"Apify\"\n}",
  "scriptTag": "<script type=\"application/ld+json\">…</script>",
  "generatedAt": "2026-09-04T20:00:00.000Z"
}

How validation works

invalid means at least one blocking error exists and no JSON-LD is emitted. Examples include a missing required field, a malformed absolute URL, an invalid date, or an incomplete FAQ/breadcrumb entry.

valid_with_warnings means the minimum contract passed but recommended fields are absent. The generated JSON-LD is usable, while the warning tells an editor what could improve it.

valid means the implemented required and recommended checks passed. It does not promise eligibility, ranking, or display in a specific search feature. Always test deployed markup with the search engine tools relevant to your site.

How much does it cost to generate Schema.org JSON-LD?

The Actor uses pay-per-event pricing:

• $0.005 per run for the start event;
• $0.012 per result on the BRONZE tier for the primary item event;
• lower per-result rates on higher Apify tiers.

Every processed entity creates a useful accounting result, including an invalid entity with actionable errors, so each dataset row incurs one item event. Entries beyond the processing limit do not produce dataset rows.

Approximate BRONZE examples:

Batch	Calculation	Price
1 result	$0.005 + 1 × $0.012	$0.017
10 results	$0.005 + 10 × $0.012	$0.125
100 results	$0.005 + 100 × $0.012	$1.205

The Apify Console shows the applicable tier and maximum charge before a run.

Schema.org JSON-LD examples

Product with an offer

{
  "items": [{
    "id": "lego-classic-10698",
    "type": "Product",
    "data": {
      "name": "LEGO Classic Large Creative Brick Box",
      "sku": "10698",
      "brand": { "@type": "Brand", "name": "LEGO" },
      "offers": {
        "@type": "Offer",
        "priceCurrency": "USD",
        "availability": "https://schema.org/InStock"
      }
    }
  }]
}

FAQ page

{
  "items": [{
    "type": "FAQPage",
    "data": {
      "questions": [{
        "question": "What is Crawlee?",
        "answer": "Crawlee is a web scraping and browser automation library."
      }]
    }
  }]
}

The FAQ request becomes mainEntity entries containing nested Question and acceptedAnswer objects. Breadcrumb requests similarly become ordered itemListElement entries.

Tips and limits

• Batch related publishing changes into one run to simplify reconciliation.
• Supply stable id values for recurring jobs.
• Use absolute http:// or https:// URLs.
• Use ISO dates such as 2026-09-04 or 2026-09-04T14:30:00-04:00.
• Use three-letter currency codes such as USD or EUR.
• Check invalid rows before copying script blocks to production.
• Treat warnings as an editorial queue, not as silent failures.
• The maximum input and maxItems value is 1,000.
• The Actor does not fetch, enrich, or verify facts from supplied URLs.
• It does not validate against every rule in Google's rich-result guidelines.
• Unsupported types such as Recipe, JobPosting, and Review fail at input validation.

Integration workflows

CMS publishing: submit approved page records, store scriptTag, and insert it into the relevant page template.

Catalog automation: map spreadsheet or database rows to Product inputs, then route invalid records to a data-quality queue.

Content release checks: generate Article and BreadcrumbList markup during a build and fail the surrounding workflow when isValid is false.

Recurring SEO operations: schedule the same stable IDs, export the dataset, and compare normalized input or JSON-LD with the previous run.

Apify integrations: send dataset rows to Google Sheets, webhooks, Make, Zapier, or another Actor without parsing logs.

API usage

Replace APIFY_TOKEN with your token. The endpoint starts this Actor and waits for dataset items.

cURL

curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~schema-org-json-ld-generator/run-sync-get-dataset-items?token=APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"items":[{"type":"Organization","data":{"name":"Apify","url":"https://apify.com/"}}]}'

JavaScript

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/schema-org-json-ld-generator').call({
  items: [{
    id: 'apify-organization',
    type: 'Organization',
    data: { name: 'Apify', url: 'https://apify.com/' },
  }],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python

from apify_client import ApifyClient

client = ApifyClient("APIFY_TOKEN")
run = client.actor("automation-lab/schema-org-json-ld-generator").call(run_input={
    "items": [{
        "id": "apify-organization",
        "type": "Organization",
        "data": {"name": "Apify", "url": "https://apify.com/"},
    }]
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

Use with MCP

Add the Actor to Claude Code:

claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/schema-org-json-ld-generator"

For Claude Desktop, Cursor, or VS Code, use this MCP JSON block:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/schema-org-json-ld-generator"
    }
  }
}

Example prompts:

• “Generate Organization JSON-LD from these approved company details.”
• “Convert this product and offer record, then list every validation warning.”
• “Create FAQPage and BreadcrumbList script blocks for this documentation page.”
• “Validate these 20 Article records and return only invalid results.”

Legality and responsible use

Only provide facts and content you are authorized to process and publish. Structured data should describe the visible page accurately. Do not use markup to misrepresent prices, availability, reviews, events, organizations, authors, or other facts to users or search engines.

The Actor processes caller-supplied data and does not bypass access controls or collect information from websites. Dataset and run retention follow the user's Apify account settings. Avoid placing secrets or unnecessary personal data in inputs.

Troubleshooting

The run fails before producing a dataset. Check that items is a non-empty array, every type matches a supported value exactly, every data value is an object, and limits are between 1 and 1,000.

A result is invalid. Read errors. Add the named required field or correct the URL/date shape, then rerun the same stable ID.

A result has warnings. The minimum fields passed. Add the recommended fields when they are accurate and visible on the target page; never invent values merely to clear warnings.

The output has fewer rows than the input. Increase maxItems. The Actor processes entries from the start of the array and stops at that explicit limit.

There is no script block. Confirm includeScriptTag is true and isValid is true. Invalid rows and runs with script output disabled have scriptTag: null.

FAQ

Does this Actor scrape a webpage automatically?

No. It deliberately converts supplied structured details. This avoids guessing facts from arbitrary page layouts and makes repeat runs deterministic.

Does valid status guarantee a Google rich result?

No. Validation covers the Actor's documented structural contract. Search engines decide eligibility and may change requirements.

Can I include extra Schema.org properties?

Yes. Extra fields inside data are preserved after recursive normalization, except questions and items, which are transformed for FAQPage and BreadcrumbList respectively.

Can one run contain different schema types?

Yes. Each item selects its own supported type and produces one independent result.

Are invalid items charged?

Yes. An invalid item still produces a useful result with normalized input and actionable errors, and therefore emits the primary result event.

Related automation-lab Actors

Use Schema-Guided Web Data to Excel for the inverse workflow: extract repeated webpage records into a consistent field schema and XLSX export, then feed approved records into this generator.

For broader page-quality checks, use Lighthouse Website Audit to measure page-level SEO, accessibility, performance, and best-practice audits.