# n8n Nodes Directory Scraper (`automation-lab/n8n-nodes-directory-scraper`) Actor

Extract public n8n node and integration metadata: package names, categories, core/community/trigger flags, popularity, URLs, and logos.

- **URL**: https://apify.com/automation-lab/n8n-nodes-directory-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Developer tools, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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 Nodes Directory Scraper

Scrape the public n8n integrations and nodes directory into a clean Apify dataset. This Actor extracts one item per n8n node or integration, including package names, descriptions, categories, core/community/trigger flags, popularity metadata, public URLs, and logo links.

Use it to build searchable automation catalogs, monitor new community nodes, enrich integration intelligence, and compare the n8n ecosystem without manually browsing the website.

### What does n8n Nodes Directory Scraper do?

The Actor fetches `https://n8n.io/integrations/`, reads the public serialized page payload, applies your filters, and saves structured node records.

It is HTTP-only and does not require an n8n account.

Key capabilities:

- ✅ Extract public n8n node and integration metadata
- ✅ Filter by search term, category, and node type
- ✅ Separate core, community, trigger, and regular nodes
- ✅ Save category names and category URLs
- ✅ Capture package/internal names for technical matching
- ✅ Export JSON, CSV, Excel, HTML, or API results from Apify

### Who is it for?

Automation agencies use it to map which apps are supported by n8n before proposing workflow builds.

SaaS partnership teams use it to check whether their product, competitors, or adjacent tools already have n8n integrations.

Developers use it to discover community packages, trigger nodes, and integration metadata for internal catalogs.

Growth teams use it to monitor the automation ecosystem and identify high-fit integration opportunities.

Data teams use it to enrich CRM, product, or marketplace records with n8n support signals.

### Why use it?

The n8n website is useful for humans, but teams often need the same information in a repeatable dataset.

This Actor gives you:

- 📦 Structured rows instead of manual copy-paste
- 🔎 Search and category filters
- 🧩 Node-type flags for segmentation
- 🔗 Public detail URLs for follow-up research
- 🕒 Repeatable runs for monitoring new integrations
- ⚙️ API-friendly output for enrichment workflows

### Data you can extract

| Field | Description |
| --- | --- |
| `displayName` | Human-readable n8n node name |
| `packageName` | Internal/package identifier when exposed |
| `description` | Public node description |
| `slug` | n8n URL slug |
| `url` | Public n8n detail page URL |
| `categories` | Category names |
| `categoryUrls` | Public category page URLs |
| `categoryDetails` | Category name and URL objects |
| `isCoreNode` | Whether the node is a core n8n node |
| `isTrigger` | Whether the node is marked as a trigger |
| `isCommunityNode` | Whether it is a community node |
| `mostPopular` | Popularity flag from the directory payload |
| `popularity` | Numeric popularity value when present |
| `createdAt` | Creation timestamp when present |
| `logoUrl` | Public logo or icon URL |
| `logoIcon` | Icon key when exposed |
| `aliases` | Alternate names or aliases |
| `scrapedAt` | Actor scrape timestamp |

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

The Actor uses pay-per-event pricing.

You pay a small start fee for each run and a per-item fee for every node saved to the dataset. Keep `maxItems` low for tests and increase it for production exports.

Exact prices are shown on the Apify Store page and in your run cost summary.

### Input options

#### n8n directory URLs

Use the default URL for the full public integrations directory:

```json
[{ "url": "https://n8n.io/integrations/" }]
````

#### Search text

Use `search` to match node names, package names, slugs, descriptions, aliases, and categories.

Examples:

- `slack`
- `google`
- `ai`
- `webhook`

#### Category contains

Use `category` when you want a category-focused export, such as:

- `Communication`
- `Marketing`
- `Developer Tools`
- `Productivity`

#### Node type

Choose one of:

- `all`
- `regular`
- `trigger`
- `core`
- `community`

#### Maximum nodes

Use `maxItems` to cap your dataset size. The prefilled value is intentionally small so your first run stays inexpensive.

### Example input

```json
{
  "startUrls": [{ "url": "https://n8n.io/integrations/" }],
  "search": "slack",
  "nodeType": "all",
  "maxItems": 25
}
```

### Example output

```json
{
  "displayName": "Slack",
  "packageName": "n8n-nodes-base.slack",
  "description": "Consume Slack API",
  "slug": "slack",
  "url": "https://n8n.io/integrations/slack/",
  "categories": ["Communication"],
  "categoryUrls": ["https://n8n.io/integrations/categories/communication/"],
  "isCoreNode": true,
  "isTrigger": false,
  "isCommunityNode": false,
  "mostPopular": true,
  "popularity": 0.95,
  "createdAt": "2021-01-01T00:00:00.000Z",
  "logoUrl": "https://.../slack.svg",
  "aliases": ["chat"],
  "scrapedAt": "2026-06-03T00:00:00.000Z"
}
```

Values vary based on the current public n8n directory payload.

### How to run it

1. Open the Actor on Apify.
2. Keep the default n8n integrations URL.
3. Add an optional search or category filter.
4. Choose a node type filter if needed.
5. Set `maxItems`.
6. Click **Start**.
7. Download the dataset or consume it via API.

### Tips for better results

- Start with `maxItems: 25` to validate your filter.
- Use `nodeType: community` to find third-party package opportunities.
- Use `nodeType: trigger` when researching event-driven workflow options.
- Leave `search` empty to export the broad directory.
- Schedule recurring runs if you want to monitor new integrations.
- Combine `category` and `nodeType` for focused market maps.

### Integrations and workflow ideas

- Send new community nodes to Slack every week.
- Load all nodes into Airtable as an integration catalog.
- Enrich CRM records with whether an app appears in n8n.
- Build a searchable internal n8n capability database.
- Compare n8n integration coverage against Zapier, Make, or your product roadmap.
- Monitor new nodes in AI, marketing, CRM, developer tools, and communication categories.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/n8n-nodes-directory-scraper').call({
  search: 'slack',
  nodeType: 'all',
  maxItems: 25,
});

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

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/n8n-nodes-directory-scraper').call(run_input={
    'search': 'slack',
    'nodeType': 'all',
    'maxItems': 25,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~n8n-nodes-directory-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"search":"slack","nodeType":"all","maxItems":25}'
```

### MCP usage

You can use this Actor through Apify MCP with Claude Code, Claude Desktop, and any MCP-compatible agent. Use the actor-specific tools URL so the client exposes only this scraper.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/n8n-nodes-directory-scraper
```

Claude Code setup:

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

Claude Desktop JSON config:

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

Example prompts:

- "Find all n8n community nodes related to AI and summarize package names."
- "Export trigger nodes from the n8n directory and group them by category."
- "Check whether Slack, HubSpot, and Notion have public n8n integrations."

### Scheduling

Schedule the Actor weekly or monthly to keep a current snapshot of the n8n integration ecosystem.

Common monitoring patterns:

- Weekly new community node review
- Monthly product integration coverage report
- Category-specific market intelligence feed
- Partner ecosystem tracking

### Data freshness

The Actor reads the public n8n directory at run time. Results reflect what the website exposes during that run.

If n8n changes its page structure, the Actor may need an update. The output includes `scrapedAt` so you can track when each row was collected.

### Limitations

This Actor scrapes the public directory, not private n8n accounts.

It does not log into n8n.

It does not execute workflows.

It does not install or validate community packages.

It only returns data that is publicly visible in the n8n integrations directory payload.

### Legality

The Actor collects publicly available directory information. You should use the data responsibly, respect n8n's terms, avoid excessive run frequency, and comply with applicable laws and your internal policies.

Do not use scraped data for spam or abusive automation.

### FAQ and troubleshooting

#### Why did I get fewer items than `maxItems`?

Your filters may match fewer nodes than requested. Remove `search`, broaden `category`, or use `nodeType: all`.

#### Why are some fields null?

The Actor only saves fields exposed by the public page payload. Some nodes may not have popularity, icon, alias, or date values.

#### Can I scrape detail pages too?

This version focuses on the directory payload for speed and reliability. Detail-page scraping can be added later if users need fields that are not in the directory data.

### Related scrapers

- https://apify.com/automation-lab/n8n-workflow-scraper
- https://apify.com/automation-lab/zapier-app-directory-scraper
- https://apify.com/automation-lab/make-templates-scraper
- https://apify.com/automation-lab/app-store-scraper

### Changelog

#### 0.1

Initial version: public n8n integrations directory extraction with filters and structured dataset output.

### Support

If you need additional n8n fields, category coverage, or detail-page enrichment, open an issue on the Apify Actor page and include your run ID.

# Actor input Schema

## `startUrls` (type: `array`):

Public n8n integrations directory URLs to parse. The default directory page already contains the full serialized node list.

## `search` (type: `string`):

Optional case-insensitive text filter matched against node name, package name, slug, description, aliases, and categories.

## `category` (type: `string`):

Optional category filter, for example AI, Marketing, Developer Tools, Communication, or Productivity.

## `nodeType` (type: `string`):

Filter by node type.

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

Maximum number of matching n8n nodes to save.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://n8n.io/integrations/"
    }
  ],
  "search": "slack",
  "nodeType": "all",
  "maxItems": 20
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://n8n.io/integrations/"
        }
    ],
    "search": "slack",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/n8n-nodes-directory-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 = {
    "startUrls": [{ "url": "https://n8n.io/integrations/" }],
    "search": "slack",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/n8n-nodes-directory-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 '{
  "startUrls": [
    {
      "url": "https://n8n.io/integrations/"
    }
  ],
  "search": "slack",
  "maxItems": 20
}' |
apify call automation-lab/n8n-nodes-directory-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "n8n Nodes Directory Scraper",
        "description": "Extract public n8n node and integration metadata: package names, categories, core/community/trigger flags, popularity, URLs, and logos.",
        "version": "0.1",
        "x-build-id": "N2jwWZoLn1GGzEhfm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~n8n-nodes-directory-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-n8n-nodes-directory-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-nodes-directory-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-n8n-nodes-directory-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-nodes-directory-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-n8n-nodes-directory-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": {
                    "startUrls": {
                        "title": "🔗 n8n directory URLs",
                        "type": "array",
                        "description": "Public n8n integrations directory URLs to parse. The default directory page already contains the full serialized node list.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "search": {
                        "title": "Search text",
                        "type": "string",
                        "description": "Optional case-insensitive text filter matched against node name, package name, slug, description, aliases, and categories."
                    },
                    "category": {
                        "title": "Category contains",
                        "type": "string",
                        "description": "Optional category filter, for example AI, Marketing, Developer Tools, Communication, or Productivity."
                    },
                    "nodeType": {
                        "title": "Node type",
                        "enum": [
                            "all",
                            "regular",
                            "trigger",
                            "core",
                            "community"
                        ],
                        "type": "string",
                        "description": "Filter by node type.",
                        "default": "all"
                    },
                    "maxItems": {
                        "title": "Maximum nodes",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of matching n8n nodes to save.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```