# Schema Markup Generator — JSON-LD Structured Data (`perryay/schema-markup-generator`) Actor
Generate Google-approved JSON-LD structured data for 30+ Schema.org types. Supports SEO schema like Article, Product, FAQ, Event, LocalBusiness, and more.
- **URL**: https://apify.com/perryay/schema-markup-generator.md
- **Developed by:** [Perry AY](https://apify.com/perryay) (community)
- **Categories:** Developer tools, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $0.01 / actor start
This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event
## What's an Apify Actor?
Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".
## How to integrate an Actor?
If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.
In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):
```bash
npm install apify-client
```
In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):
```bash
pip install apify-client
```
In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):
````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash
In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).
If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).
For usage examples, see the [API](#api) section below.
For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).
# README
## Schema Markup Generator — JSON-LD Structured Data for SEO
Generate **Google-approved JSON-LD structured data** for 30+ Schema.org types in one call. Whether you need an Article, Product, FAQ, Event, LocalBusiness, Recipe, or any of 25+ other schema types, this actor produces valid, ready-to-use JSON-LD markup — no manual template writing required.
### What does it do?
**Schema Markup Generator** takes your content data and a schema type, then generates the correct JSON-LD structured data following Schema.org specifications. It understands required vs. recommended fields per schema type, validates your data, and produces clean markup you can drop directly into your HTML `` or test in Google's Rich Results Test.
### Who is it for?
| Persona | What they use it for |
|---|---|
| SEO Professional | Generating structured data for content pages, products, and local business listings |
| Web Developer | Adding JSON-LD to websites without writing schema templates manually |
| Content Marketer | Creating rich snippets for blog posts, FAQs, recipes, and events |
| E-commerce Manager | Generating Product and ProductGroup markup for product catalog pages |
| Data Analyst | Building Dataset schema for structured data publishing |
| QA Tester | Validating schema markup across thousands of pages in bulk |
### Features
- **30+ schema types** — Article, Product, FAQ, Event, LocalBusiness, Recipe, Person, Organization, BreadcrumbList, BlogPosting, Book, Course, CreativeWork, Dataset, EducationalCredential, FactCheck, HowTo, ImageObject, JobPosting, Movie, MusicAlbum, MusicGroup, NewsArticle, PodcastEpisode, ProductGroup, Question, Review, SoftwareApplication, VideoObject, WebPage, WebSite
- **Bulk generation** — Process hundreds of items from a JSON array in a single run
- **Built-in validation** — Checks required fields, recommended fields, and unknown fields per schema type
- **Flexible output** — Raw JSON-LD or complete HTML `
```
### Input Parameters
| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `schemaType` | string | ✅ Yes | Schema.org type (one of 32 supported types) |
| `data` | object | See note | Single item's structured data fields |
| `items` | array | See note | Array of data objects for bulk generation |
| `outputFormat` | string | No | `json-ld` (default) or `script-tag` |
| `includeContext` | boolean | No | Include `@context` field (default: true) |
| `validateMarkup` | boolean | No | Run validation (default: true) |
> **Note:** Either `data` or `items` must be provided. If both are provided, `items` takes precedence.
### Supported Schema Types
| Category | Types |
|----------|-------|
| **Articles** | Article, BlogPosting, NewsArticle |
| **Products** | Product, ProductGroup |
| **Business** | LocalBusiness, Organization |
| **Media** | ImageObject, VideoObject, Movie |
| **Music** | MusicAlbum, MusicGroup |
| **Events** | Event |
| **People** | Person |
| **Lists** | BreadcrumbList |
| **FAQs** | FAQ (FAQPage) |
| **Recipes** | Recipe, HowTo |
| **Education** | Course, EducationalOccupationalCredential |
| **Reviews** | Review, EmployerAggregateRating |
| **Creative** | CreativeWork, Book, FactCheck, Question |
| **Data** | Dataset |
| **Jobs** | JobPosting |
| **Audio** | PodcastEpisode |
| **Software** | SoftwareApplication |
| **Web** | WebPage, WebSite |
### Input Schema
```json
{
"schemaType": "Article",
"data": {
"name": "Example Article",
"description": "Article description",
"url": "https://example.com/article"
}
}
```
### Why use this?
- **No manual schema templates** — Choose a type, provide your data, get valid JSON-LD
- **Bulk processing** — Generate markup for hundreds of pages in a single run
- **Validation built in** — Catches missing required fields and warns about missing recommended ones
- **SEO-ready output** — Works directly with Google Rich Results, Bing Webmaster Tools, and Yandex
- **Developer-friendly** — Clean JSON output, script tag support, and batched input
### FAQ
1. **What schema types are supported?**
30+ types including Article, Product, FAQ, Event, LocalBusiness, Recipe, and more. See the Supported Schema Types section for the full list.
2. **Is the output Google Rich Results compatible?**
Yes. The generated JSON-LD follows Schema.org specifications and passes Google Rich Results Test validation.
3. **Can I use this in CI/CD pipelines?**
Yes. The API-first design lets you integrate schema generation into build pipelines using the Apify API.
4. **What's the difference between `data` and `items`?**
`data` is for a single item, `items` is an array for bulk processing. If both are provided, `items` takes precedence.
5. **Does this actor validate existing schema markup?**
It generates new markup and validates its own output against Schema.org requirements. For auditing existing markup, see our Schema Validator tools.
6. **Can I customize the output format?**
Yes. Choose between raw JSON-LD (`json-ld`) or complete HTML script tags (`script-tag`).
7. **What happens if validation fails?**
The actor returns detailed error messages explaining which fields are missing or invalid.
8. **How many items can I process in bulk?**
There's no hard limit, but we recommend keeping batches under 100 items for optimal performance.
9. **Do I need an API key for this actor?**
No external API keys needed. Just an Apify account.
10. **Can I generate multiple schema types in one run?**
No. Each run handles one schema type. Use multiple runs or the bulk mode with items.
### MCP Integration
Add this actor to your MCP client:
```json
{
"mcpServers": {
"apify": {
"url": "https://mcp.apify.com"
}
}
}
```
### Related Tools
- [Schema Validator & Generator](https://apify.com/perryay/json-schema-validator-generator) — Validate JSON Schema and generate structured data schemas
- [Website Tech Stack Detector](https://apify.com/perryay/website-tech-stack-detector) — Detect technologies powering any website
- [OG Preview Generator](https://apify.com/perryay/og-preview-generator) — Preview and generate Open Graph meta tags for social sharing
- [Data Format Converter](https://apify.com/perryay/data-format-converter) — Convert between CSV, JSON, XML, and other data formats
### SEO Keywords
JSON-LD generator, schema markup, structured data, rich results, SEO schema, Schema.org generator, FAQ schema, Product schema, Article schema, JSON-LD validator, semantic SEO, Google rich snippets
# Actor input Schema
## `schemaType` (type: `string`):
The Schema.org type to generate markup for
## `data` (type: `object`):
JSON object of schema properties. Use the field names expected by the selected Schema.org type. For nested objects, use valid JSON syntax.
## `items` (type: `array`):
Array of data objects for bulk generation. When set, each item in the array will generate separate markup. Overrides the single 'data' field.
## `outputFormat` (type: `string`):
Format for the generated markup
## `includeContext` (type: `boolean`):
Include the @context field in each generated markup item
## `validateMarkup` (type: `boolean`):
Run basic validation on generated markup (checks required fields, data types)
## Actor input object example
```json
{
"schemaType": "Article",
"data": {
"name": "Example Item",
"description": "A sample description",
"url": "https://example.com/item"
},
"items": [],
"outputFormat": "json-ld",
"includeContext": true,
"validateMarkup": true
}
```
# Actor output Schema
## `results` (type: `string`):
Generated JSON-LD markup items in the default dataset
# API
You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.
## JavaScript example
```javascript
import { ApifyClient } from 'apify-client';
// Initialize the ApifyClient with your Apify API token
// Replace the '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"data": {
"name": "Example Item",
"description": "A sample description",
"url": "https://example.com/item"
},
"items": []
};
// Run the Actor and wait for it to finish
const run = await client.actor("perryay/schema-markup-generator").call(input);
// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
console.dir(item);
});
// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs
```
## Python example
```python
from apify_client import ApifyClient
# Initialize the ApifyClient with your Apify API token
# Replace '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"data": {
"name": "Example Item",
"description": "A sample description",
"url": "https://example.com/item",
},
"items": [],
}
# Run the Actor and wait for it to finish
run = client.actor("perryay/schema-markup-generator").call(run_input=run_input)
# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
print(item)
# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start
```
## CLI example
```bash
echo '{
"data": {
"name": "Example Item",
"description": "A sample description",
"url": "https://example.com/item"
},
"items": []
}' |
apify call perryay/schema-markup-generator --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=perryay/schema-markup-generator",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "Schema Markup Generator — JSON-LD Structured Data",
"description": "Generate Google-approved JSON-LD structured data for 30+ Schema.org types. Supports SEO schema like Article, Product, FAQ, Event, LocalBusiness, and more.",
"version": "1.0",
"x-build-id": "r9gLbTstJHCNLQbLf"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/perryay~schema-markup-generator/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-perryay-schema-markup-generator",
"x-openai-isConsequential": false,
"summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK"
}
}
}
},
"/acts/perryay~schema-markup-generator/runs": {
"post": {
"operationId": "runs-sync-perryay-schema-markup-generator",
"x-openai-isConsequential": false,
"summary": "Executes an Actor and returns information about the initiated run in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/runsResponseSchema"
}
}
}
}
}
}
},
"/acts/perryay~schema-markup-generator/run-sync": {
"post": {
"operationId": "run-sync-perryay-schema-markup-generator",
"x-openai-isConsequential": false,
"summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK"
}
}
}
}
},
"components": {
"schemas": {
"inputSchema": {
"type": "object",
"required": [
"schemaType"
],
"properties": {
"schemaType": {
"title": "Schema Type",
"enum": [
"Article",
"BlogPosting",
"NewsArticle",
"Product",
"ProductGroup",
"FAQ",
"Event",
"LocalBusiness",
"Recipe",
"Person",
"Organization",
"BreadcrumbList",
"Book",
"Course",
"CreativeWork",
"Dataset",
"EducationalOccupationalCredential",
"EmployerAggregateRating",
"FactCheck",
"HowTo",
"ImageObject",
"JobPosting",
"Movie",
"MusicAlbum",
"MusicGroup",
"PodcastEpisode",
"Question",
"Review",
"SoftwareApplication",
"VideoObject",
"WebPage",
"WebSite"
],
"type": "string",
"description": "The Schema.org type to generate markup for",
"default": "Article"
},
"data": {
"title": "Structured Data Fields (JSON)",
"type": "object",
"description": "JSON object of schema properties. Use the field names expected by the selected Schema.org type. For nested objects, use valid JSON syntax."
},
"items": {
"title": "Bulk Items (JSON Array)",
"type": "array",
"description": "Array of data objects for bulk generation. When set, each item in the array will generate separate markup. Overrides the single 'data' field."
},
"outputFormat": {
"title": "Output Format",
"enum": [
"json-ld",
"script-tag"
],
"type": "string",
"description": "Format for the generated markup",
"default": "json-ld"
},
"includeContext": {
"title": "Include @context",
"type": "boolean",
"description": "Include the @context field in each generated markup item",
"default": true
},
"validateMarkup": {
"title": "Validate Generated Markup",
"type": "boolean",
"description": "Run basic validation on generated markup (checks required fields, data types)",
"default": true
}
}
},
"runsResponseSchema": {
"type": "object",
"properties": {
"data": {
"type": "object",
"properties": {
"id": {
"type": "string"
},
"actId": {
"type": "string"
},
"userId": {
"type": "string"
},
"startedAt": {
"type": "string",
"format": "date-time",
"example": "2025-01-08T00:00:00.000Z"
},
"finishedAt": {
"type": "string",
"format": "date-time",
"example": "2025-01-08T00:00:00.000Z"
},
"status": {
"type": "string",
"example": "READY"
},
"meta": {
"type": "object",
"properties": {
"origin": {
"type": "string",
"example": "API"
},
"userAgent": {
"type": "string"
}
}
},
"stats": {
"type": "object",
"properties": {
"inputBodyLen": {
"type": "integer",
"example": 2000
},
"rebootCount": {
"type": "integer",
"example": 0
},
"restartCount": {
"type": "integer",
"example": 0
},
"resurrectCount": {
"type": "integer",
"example": 0
},
"computeUnits": {
"type": "integer",
"example": 0
}
}
},
"options": {
"type": "object",
"properties": {
"build": {
"type": "string",
"example": "latest"
},
"timeoutSecs": {
"type": "integer",
"example": 300
},
"memoryMbytes": {
"type": "integer",
"example": 1024
},
"diskMbytes": {
"type": "integer",
"example": 2048
}
}
},
"buildId": {
"type": "string"
},
"defaultKeyValueStoreId": {
"type": "string"
},
"defaultDatasetId": {
"type": "string"
},
"defaultRequestQueueId": {
"type": "string"
},
"buildNumber": {
"type": "string",
"example": "1.0.0"
},
"containerUrl": {
"type": "string"
},
"usage": {
"type": "object",
"properties": {
"ACTOR_COMPUTE_UNITS": {
"type": "integer",
"example": 0
},
"DATASET_READS": {
"type": "integer",
"example": 0
},
"DATASET_WRITES": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_READS": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_WRITES": {
"type": "integer",
"example": 1
},
"KEY_VALUE_STORE_LISTS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_READS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_WRITES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_INTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_EXTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_SERPS": {
"type": "integer",
"example": 0
}
}
},
"usageTotalUsd": {
"type": "number",
"example": 0.00005
},
"usageUsd": {
"type": "object",
"properties": {
"ACTOR_COMPUTE_UNITS": {
"type": "integer",
"example": 0
},
"DATASET_READS": {
"type": "integer",
"example": 0
},
"DATASET_WRITES": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_READS": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_WRITES": {
"type": "number",
"example": 0.00005
},
"KEY_VALUE_STORE_LISTS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_READS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_WRITES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_INTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_EXTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_SERPS": {
"type": "integer",
"example": 0
}
}
}
}
}
}
}
}
}
}
```