# n8n Workflow Templates Scraper (`automation-lab/n8n-workflow-scraper`) Actor

Extract n8n workflow templates with full metadata: nodes, categories, views, creator info, and importable workflow JSON. 9,000+ templates. No API key needed.

- **URL**: https://apify.com/automation-lab/n8n-workflow-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Developer tools, AI
- **Stats:** 2 total users, 2 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## n8n Workflow Templates Scraper

Extract the complete **n8n workflow template library** — 9,000+ automation templates with full metadata, node lists, categories, view counts, creator info, and importable workflow JSON. No API key needed. Search by keyword, filter by category, or bulk-download all templates for analysis or dataset building.

### What does n8n Workflow Templates Scraper do?

[n8n](https://n8n.io) is one of the fastest-growing open-source automation platforms with over 9,049 public workflow templates covering AI agents, CRM automation, marketing, DevOps, support, and more. This scraper connects to the **n8n public REST API** and extracts complete template data — including the raw workflow JSON you can import directly into your n8n instance.

Use it to browse AI workflow patterns, analyze which nodes are trending, build training datasets for automation assistants, or monitor new templates as they're published.

**No API key, no login, no browser automation.** Pure HTTP — fast, cheap, and reliable.

### Who is n8n Workflow Templates Scraper for?

#### 🤖 AI / automation researchers
- Download all n8n AI agent templates to study workflow design patterns
- Build fine-tuning datasets from real-world workflow JSON
- Analyze which LLM nodes (OpenAI, Gemini, Anthropic) appear most in popular templates

#### 🏢 No-code teams and consultants
- Find pre-built templates matching your stack (Slack, HubSpot, Salesforce, Notion)
- Export a category's worth of templates into Google Sheets for team review
- Monitor new templates in specific categories weekly

#### 📊 Data analysts and market researchers
- Track which tools (nodes) are growing in popularity over time
- Identify gaps: integrations the community needs but doesn't have yet
- Export template view counts and creator stats for competitive analysis

#### 🛠 Developers and DevRel teams
- Check if your product's n8n node has community templates
- Benchmark template quality and adoption vs competitors
- Extract workflow structures to test your node implementation

### Why use n8n Workflow Templates Scraper?

- ✅ **9,000+ templates** — the complete public library, not just top results
- ✅ **Importable workflow JSON** — get the full node graph, connections, and settings
- ✅ **No API key or n8n account needed** — the public API is open
- ✅ **Pure HTTP, no browser** — 50 templates/second, no proxy needed
- ✅ **Rich metadata** — views, categories, creator info, node lists in a single record
- ✅ **Keyword search** — target exactly the templates you need
- ✅ **Category filter** — narrow to AI, Sales, Marketing, IT Ops, and 20+ categories
- ✅ **Apify platform** — schedule daily runs, export to JSON/CSV/Excel, integrate with 5,000+ apps

### What data can you extract?

| Field | Description |
|---|---|
| `id` | Numeric template ID |
| `name` | Template name |
| `description` | Full description (markdown, often 500–2000 words) |
| `templateUrl` | Direct URL to template on n8n.io |
| `totalViews` | Lifetime view count |
| `createdAt` | Publication date (ISO 8601) |
| `categories` | Template categories (AI, Sales, Marketing, etc.) |
| `nodeCount` | Number of nodes in the workflow |
| `nodeNames` | Internal node identifiers (e.g. `n8n-nodes-base.slack`) |
| `nodeDisplayNames` | Human-readable node names (e.g. "Slack", "AI Agent") |
| `creatorName` | Author display name |
| `creatorUsername` | Author username (for n8n profile URL) |
| `creatorVerified` | Whether author is verified |
| `creatorAvatar` | Author avatar URL |
| `workflowJson` | Full importable workflow JSON (nodes, connections, settings) |
| `scrapedAt` | Timestamp when record was scraped |

**Total: 15 fields per template**, including the complete workflow structure.

### How much does it cost to scrape n8n templates?

This Actor uses **pay-per-event** pricing — you pay only for templates you extract. No monthly subscription. All platform costs are **included**.

| | Free ($5 credit) | Starter ($29/mo) | Scale ($199/mo) | Business ($999/mo) |
|---|---|---|---|---|
| **Per template** | ~$0.00115 | $0.001 | ~$0.00078 | ~$0.0006 |
| **100 templates** | ~$0.12 | ~$0.10 | ~$0.08 | ~$0.06 |
| **1,000 templates** | ~$1.15 | ~$1.00 | ~$0.78 | ~$0.60 |
| **All 9,049 templates** | ~$10.41 | ~$9.05 | ~$7.06 | ~$5.43 |

**Run start fee: $0.005** (one-time per run, covers API initialization).

**Real-world cost examples:**

| Use case | Templates | With workflow JSON | Duration | Cost (Free) |
|---|---|---|---|---|
| Quick keyword search | 20 | Yes | ~20s | ~$0.03 |
| Category deep-dive | 100 | Yes | ~2 min | ~$0.12 |
| Full library export | 9,049 | No | ~5 min | ~$9.10 |
| Full library with JSON | 9,049 | Yes | ~25 min | ~$9.10 |

**Free plan estimate:** With $5 in credits, you can scrape ~4,300 templates with workflow JSON — or all 9,049 without.

### How to scrape n8n workflow templates

1. Go to [n8n Workflow Templates Scraper](https://apify.com/automation-lab/n8n-workflow-scraper) on the Apify Store
2. Click **Try for free**
3. Enter a **Search query** (e.g., `openai`, `slack CRM`, `lead generation`) or leave blank for all templates
4. Optionally select **Categories** to filter (AI, Sales, Marketing, IT Ops, etc.)
5. Set **Max templates** — use `0` for unlimited (all results)
6. Toggle **Include workflow JSON** on if you want importable workflow data
7. Click **Start** and wait for results (seconds to minutes depending on volume)
8. Download as **JSON**, **CSV**, or **Excel** from the Dataset tab

#### Example inputs

**Search for AI agent templates:**
```json
{
    "searchQuery": "AI agent",
    "maxItems": 100,
    "includeWorkflowJson": true
}
````

**Get all templates without workflow JSON (fastest):**

```json
{
    "searchQuery": "",
    "maxItems": 0,
    "includeWorkflowJson": false,
    "pageSize": 100
}
```

**Filter by category:**

```json
{
    "categories": ["AI", "Marketing"],
    "maxItems": 200,
    "includeWorkflowJson": false
}
```

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `searchQuery` | String | `""` | Keyword search (e.g. "slack", "openai", "email"). Leave blank for all templates. |
| `categories` | Array | `[]` | Filter by category name. Options: AI, Sales, Marketing, IT Ops, Support, Other, AI Chatbot, AI RAG, Content Creation, CRM, Lead Generation, Social Media, DevOps, SecOps, Document Ops, Engineering, HR, Personal Productivity, Project Management. |
| `maxItems` | Integer | `100` | Max templates to extract. `0` = unlimited. |
| `includeWorkflowJson` | Boolean | `true` | Include full importable workflow JSON in output. |
| `sortBy` | String | `"relevance"` | Sort order: `relevance` or `recent`. |
| `pageSize` | Integer | `50` | Templates per API request (10–100). Higher = fewer requests. |

### Output examples

```json
{
    "id": 6270,
    "name": "Build Your First AI Agent",
    "description": "### How it works\n\nThis template launches your very first AI Agent...",
    "templateUrl": "https://n8n.io/workflows/6270",
    "totalViews": 99862,
    "createdAt": "2025-07-22T12:14:21.343Z",
    "categories": ["Personal Productivity", "AI Chatbot"],
    "nodeCount": 3,
    "nodeNames": [
        "@n8n/n8n-nodes-langchain.agent",
        "@n8n/n8n-nodes-langchain.memoryBufferWindow",
        "@n8n/n8n-nodes-langchain.lmChatGoogleGemini"
    ],
    "nodeDisplayNames": ["AI Agent", "Simple Memory", "Google Gemini Chat Model"],
    "creatorName": "Lucas Peyrin",
    "creatorUsername": "lucaspeyrin",
    "creatorVerified": true,
    "creatorAvatar": "https://gravatar.com/avatar/...",
    "workflowJson": {
        "meta": { "instanceId": "..." },
        "nodes": [...],
        "connections": {...}
    },
    "scrapedAt": "2026-04-03T10:30:00.000Z"
}
```

### Tips for best results

- 🔍 **Start with a keyword search** — searching for specific tools (slack, hubspot, openai) returns highly relevant results fast
- 💰 **Disable workflow JSON for bulk exports** — if you only need metadata and node lists, set `includeWorkflowJson: false` to reduce costs by ~50% on large runs
- 📦 **Use `pageSize: 100`** for maximum efficiency when scraping thousands of templates — fewer API requests, same speed
- 🗂 **Category filtering is client-side** — the scraper fetches and filters locally since the n8n API doesn't support server-side category filtering. Large category filters with `includeWorkflowJson: false` will be fast; with workflow JSON they'll be slower (one detail request per match)
- ⏰ **Schedule weekly runs** to track new templates — n8n adds dozens of new templates weekly. Use Apify scheduling to monitor your target category
- 📊 **Export to Google Sheets** for team collaboration — use the Apify Google Sheets integration to push fresh template data automatically

### Integrations

#### n8n Workflow Templates Scraper → Google Sheets

Use the built-in **Google Sheets** export or the Apify Google Sheets integration to maintain a live spreadsheet of n8n templates in specific categories. Useful for consulting teams researching client automation options.

#### n8n Workflow Templates Scraper → Slack/Discord

Set up a scheduled run + webhook to post newly published templates matching your keywords to a Slack channel. Never miss a new AI agent or CRM template again.

#### n8n Workflow Templates Scraper → Apify Dataset → Make/Zapier

Chain with Make or Zapier webhooks to trigger downstream actions when new templates are found — auto-import into Notion, create Jira tickets for template reviews, or feed your internal knowledge base.

#### Build AI training datasets

Run the scraper with `includeWorkflowJson: true` and `maxItems: 0` to get all 9,000+ workflow JSONs. Use the dataset as fine-tuning data for automation-aware LLMs or for RAG systems that help users build n8n workflows.

#### Monitor competitor integrations

Extract all templates that use a specific node (e.g., your product's n8n integration) by searching for your product name. Track views over time to measure adoption.

### Using the Apify API

#### Node.js

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('automation-lab/n8n-workflow-scraper').call({
    searchQuery: 'AI agent',
    maxItems: 100,
    includeWorkflowJson: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Scraped ${items.length} templates`);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient(token='YOUR_APIFY_TOKEN')

run = client.actor('automation-lab/n8n-workflow-scraper').call(run_input={
    'searchQuery': 'AI agent',
    'maxItems': 100,
    'includeWorkflowJson': True,
})

items = list(client.dataset(run['defaultDatasetId']).iterate_items())
print(f'Scraped {len(items)} templates')
```

#### cURL

```bash
## Start the actor
curl -X POST "https://api.apify.com/v2/acts/automation-lab~n8n-workflow-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQuery": "AI agent",
    "maxItems": 100,
    "includeWorkflowJson": true
  }'

## Get results (replace DATASET_ID with run's defaultDatasetId)
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_APIFY_TOKEN&format=json"
```

### Use with AI agents via MCP

n8n Workflow Templates Scraper is available as a tool for AI assistants that support the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp).

Add the Apify MCP server to your AI client — this gives you access to all Apify actors, including this one:

#### Setup for Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/n8n-workflow-scraper"
```

#### Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com?tools=automation-lab/n8n-workflow-scraper"
        }
    }
}
```

Your AI assistant will use OAuth to authenticate with your Apify account on first use.

#### Example prompts

Once connected, try asking your AI assistant:

- "Use automation-lab/n8n-workflow-scraper to find all n8n templates that use OpenAI and return the top 20 by view count"
- "Scrape n8n templates in the Sales category and summarize the most common node combinations"
- "Get the workflow JSON for the top 5 most-viewed AI agent templates on n8n"

Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).

### Is it legal to scrape n8n workflow templates?

The n8n template library is publicly accessible without authentication. This scraper uses the **official public REST API** at `api.n8n.io` — the same API the n8n website uses. No authentication bypass, no rate-limit circumvention, no scraping of protected user data.

All extracted data is **publicly available** on [n8n.io/workflows](https://n8n.io/workflows/). We respect the API's natural rate limits and do not store or redistribute personal data (creator info is limited to what's publicly displayed on their profile pages).

Use responsibly:

- Do not use this data to clone or redistribute the n8n template library commercially
- Respect n8n's [Terms of Service](https://n8n.io/legal/terms/)
- For high-volume automated access, consider n8n's enterprise API options

### FAQ

**How fast is the scraper?**
Without workflow JSON: ~50 templates per second (limited by API pagination). With workflow JSON: ~1 template per second (one detail API call per template). A full library export of 9,049 templates takes ~3 minutes without JSON or ~30 minutes with JSON.

**How much does it cost to scrape all 9,049 templates?**
Approximately $9.05 on the Starter plan ($0.001/template + $0.005 start fee). On the free plan with $5 in credits, you can scrape about 4,300 templates with workflow JSON, or all templates without it.

**Why is category filtering slow with workflow JSON enabled?**
The n8n public API doesn't support server-side category filtering — it returns all templates regardless of category. The scraper filters client-side after fetching each template's detail page (which contains accurate categories). Without workflow JSON, category filtering uses node-level categories from the search response (faster but less precise).

**Why are some `categories` lists different from what I see on n8n.io?**
When `includeWorkflowJson` is enabled, categories come from the detail API and match n8n.io exactly. When `includeWorkflowJson` is disabled, categories are derived from the node types in the search response and may differ slightly.

**The scraper returned fewer templates than expected. Why?**
When using category filtering with `includeWorkflowJson: false`, the categories are node-level (e.g., "AI", "Langchain") rather than template-level. Enable `includeWorkflowJson: true` for accurate category filtering — this fetches the template detail page which has the correct template categories.

**Can I use the workflow JSON to import templates into my n8n instance?**
Yes. The `workflowJson` field contains the complete workflow definition. In n8n, go to **Workflows → New → Import from JSON** and paste the value of the `workflowJson` field.

**Is the n8n API rate-limited?**
The API has soft rate limits. The scraper includes automatic retry with exponential backoff on 429 responses. For large runs (1,000+ templates with JSON), occasional brief delays may occur.

### Other automation scrapers

Looking for more workflow and automation tools?

- [Apify Store Analyzer](https://apify.com/automation-lab/apify-store-analyzer) — Analyze the Apify Store actor catalog
- [ArXiv Scraper](https://apify.com/automation-lab/arxiv-scraper) — Extract research papers and technical docs
- [Bing News Scraper](https://apify.com/automation-lab/bing-news-scraper) — Track automation industry news

# Actor input Schema

## `searchQuery` (type: `string`):

Enter a keyword to search templates (e.g. 'slack', 'openai', 'email automation'). Leave blank to scrape all templates.

## `categories` (type: `array`):

Filter templates by category name. Leave blank to include all categories. Available categories: AI, Sales, Marketing, IT Ops, Support, Other, AI Chatbot, AI RAG, AI Summarization, Content Creation, CRM, Lead Generation, Social Media, DevOps, SecOps, Document Ops, Engineering, HR, Personal Productivity, Project Management.

## `maxItems` (type: `integer`):

Maximum number of templates to extract. Set to 0 for unlimited (all matching templates).

## `includeWorkflowJson` (type: `boolean`):

Include the full workflow JSON (nodes, connections, settings) so you can import the template directly into n8n.

## `sortBy` (type: `string`):

Sort templates by relevance (default for searches) or by recency.

## `pageSize` (type: `integer`):

Number of templates fetched per API request (10–100). Higher values mean fewer requests.

## Actor input object example

```json
{
  "searchQuery": "AI agent",
  "categories": [],
  "maxItems": 20,
  "includeWorkflowJson": true,
  "sortBy": "relevance",
  "pageSize": 50
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchQuery": "AI agent",
    "categories": [],
    "maxItems": 20,
    "pageSize": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/n8n-workflow-scraper").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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchQuery": "AI agent",
    "categories": [],
    "maxItems": 20,
    "pageSize": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/n8n-workflow-scraper").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 '{
  "searchQuery": "AI agent",
  "categories": [],
  "maxItems": 20,
  "pageSize": 50
}' |
apify call automation-lab/n8n-workflow-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/n8n-workflow-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "n8n Workflow Templates Scraper",
        "description": "Extract n8n workflow templates with full metadata: nodes, categories, views, creator info, and importable workflow JSON. 9,000+ templates. No API key needed.",
        "version": "0.1",
        "x-build-id": "9PMegSJk5bgX4IsbP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~n8n-workflow-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-n8n-workflow-scraper",
                "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/automation-lab~n8n-workflow-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-n8n-workflow-scraper",
                "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/automation-lab~n8n-workflow-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-n8n-workflow-scraper",
                "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",
                "properties": {
                    "searchQuery": {
                        "title": "🔍 Search query",
                        "type": "string",
                        "description": "Enter a keyword to search templates (e.g. 'slack', 'openai', 'email automation'). Leave blank to scrape all templates."
                    },
                    "categories": {
                        "title": "📂 Categories",
                        "type": "array",
                        "description": "Filter templates by category name. Leave blank to include all categories. Available categories: AI, Sales, Marketing, IT Ops, Support, Other, AI Chatbot, AI RAG, AI Summarization, Content Creation, CRM, Lead Generation, Social Media, DevOps, SecOps, Document Ops, Engineering, HR, Personal Productivity, Project Management.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "📊 Max templates",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of templates to extract. Set to 0 for unlimited (all matching templates).",
                        "default": 100
                    },
                    "includeWorkflowJson": {
                        "title": "📥 Include workflow JSON",
                        "type": "boolean",
                        "description": "Include the full workflow JSON (nodes, connections, settings) so you can import the template directly into n8n.",
                        "default": true
                    },
                    "sortBy": {
                        "title": "⚙️ Sort order",
                        "enum": [
                            "relevance",
                            "recent"
                        ],
                        "type": "string",
                        "description": "Sort templates by relevance (default for searches) or by recency.",
                        "default": "relevance"
                    },
                    "pageSize": {
                        "title": "Page size",
                        "minimum": 10,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Number of templates fetched per API request (10–100). Higher values mean fewer requests.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
