# Civitai Models Scraper (`parseforge/civitai-models-scraper`) Actor

Query the Civitai catalog of community Stable Diffusion models. Records include id, name, type, creator, downloads, favorites, rating, base model, tags, NSFW flag, size, and URL. Useful for AI art research, model curation, and tracking trends across community submissions.

- **URL**: https://apify.com/parseforge/civitai-models-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** AI, For creators, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.50 / 1,000 results

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🎨 Civitai Public Models API Scraper

> 🚀 **Export Civitai public model metadata in seconds. ID, name, type, creator, downloads, favorites, rating, tags, NSFW flag, base model, versions, and file size, straight from the public civitai.com API.**

> 🕒 **Last updated:** 2026-06-05 · **📊 15 fields** per record · Full Civitai catalogue · Checkpoints, LoRAs, ControlNets, VAEs, and more

The Civitai Public Models API Scraper turns the [civitai.com/api/v1/models](https://civitai.com/api/v1/models) public REST endpoint into a clean dataset. It paginates through the catalogue with whatever sort, type, base model, and NSFW filters you supply, then flattens each model into one row.

Coverage spans the full Civitai catalogue, the largest open community for Stable Diffusion checkpoints, LoRAs, ControlNets, textual inversions, VAEs, and motion modules. Each row carries id, name, type, creator, download and favorite counts, rating, tags, NSFW flag, base model name, version count, and first file size in KB.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| 🎨 AI artists | Discover top LoRAs and checkpoints |
| 📊 ML researchers | Track open generative model ecosystem |
| 🏢 Platform teams | Mirror Civitai into internal galleries |
| 🧑‍🎓 Educators | Curate generative art teaching sets |
| 📰 AI journalists | Source community gen-AI stories |
| 👩‍💻 Developers | Power discovery features with Civitai data |

### 📋 What the Civitai Public Models API Scraper does

- Calls `/api/v1/models` with your chosen sort, query, type, and base model filters.
- Paginates via the Civitai cursor field.
- Flattens nested stats, creator, and first-version data into top-level fields.
- Surfaces upstream errors as a clean error record.
- Exports as CSV, Excel, JSON, JSONL, XML, RSS, or HTML.

> 💡 **Why it matters:** Civitai is the open hub for Stable Diffusion and related generative models. This actor turns its catalogue into a structured dataset for trend tracking and discovery.

### 🎬 Full Demo

_🚧 Coming soon._

### ⚙️ Input

<table>
<tr><th>Field</th><th>Type</th><th>Required</th><th>Description</th></tr>
<tr><td><code>query</code></td><td>string</td><td>No</td><td>Free-text search across model names.</td></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td>No</td><td>Free users 10, paid up to 1,000,000. Prefill is 10.</td></tr>
<tr><td><code>sort</code></td><td>enum</td><td>No</td><td>Highest Rated, Most Downloaded, or Newest.</td></tr>
<tr><td><code>type</code></td><td>enum</td><td>No</td><td>Checkpoint, LoRA, ControlNet, etc.</td></tr>
<tr><td><code>baseModel</code></td><td>string</td><td>No</td><td>SD 1.5, SDXL 1.0, Pony, Flux.1 D.</td></tr>
<tr><td><code>nsfw</code></td><td>boolean</td><td>No</td><td>Allow NSFW models. Default false.</td></tr>
</table>

**Example 1, top rated checkpoints:**
```json
{ "sort": "Highest Rated", "type": "Checkpoint", "maxItems": 50 }
````

**Example 2, SDXL LoRAs:**

```json
{ "type": "LORA", "baseModel": "SDXL 1.0", "maxItems": 100 }
```

> ⚠️ **Good to Know:** The Civitai API is public. Optionally set a `CIVITAI_API_KEY` environment variable for higher rate limits. The key is read server-side and never exposed in the input.

### 📊 Output

| Field | Type | Description |
|---|---|---|
| 🆔 `id` | number | Civitai model id. |
| 🎨 `name` | string | Model name. |
| 🏷️ `type` | string | Model type. |
| 👤 `creator` | string | Creator username. |
| ⬇️ `downloadCount` | number | Download count. |
| ❤️ `favoriteCount` | number | Favorite count. |
| ⭐ `rating` | number | Average rating. |
| 🏷️ `tags` | array | Tag array. |
| 🔞 `nsfw` | boolean | NSFW flag. |
| 🧠 `baseModel` | string | Base model for the first version. |
| 🔖 `versions` | number | Total version count. |
| 💾 `fileSize` | number | First-file size in KB. |
| 🔗 `url` | string | Direct link. |
| 🕒 `scrapedAt` | string | When fetched. |
| ❌ `error` | string | Set if the upstream response was an error. |

**Sample record:**

```json
{
  "id": 12345,
  "name": "Vintage Film LoRA",
  "type": "LORA",
  "creator": "artistx",
  "downloadCount": 84231,
  "favoriteCount": 4231,
  "rating": 4.92,
  "tags": ["style","film","retro"],
  "nsfw": false,
  "baseModel": "SDXL 1.0",
  "versions": 3,
  "fileSize": 152300,
  "url": "https://civitai.com/models/12345",
  "scrapedAt": "2026-06-05T12:00:00.000Z",
  "error": null
}
```

### ✨ Why choose this Actor

| 🆓 | Public Civitai API, no key required (optional for higher rate limits). |
| 🎨 | Built for the Stable Diffusion ecosystem. |
| 🔢 | Casts download, favorite, and rating counts for clean spreadsheet imports. |
| 🛟 | Surfaces upstream errors as clean rows. |
| 🔌 | Sort, query, type, base model, and NSFW filters exposed. |
| 💾 | Push to dataset for CSV, Excel, JSON, XML, or RSS export. |

### 📈 How it compares to alternatives

| Approach | Setup | Pagination | Flattening | Export formats |
|---|---|---|---|---|
| Raw `curl` | 5 min | manual | none | manual |
| DIY Python script | 30 min | yes | partial | code |
| **This Actor** | 5 seconds | yes | yes | 7 formats |

### 🚀 How to use

1. Click **Try for free**.
2. Pick a sort and optional filters.
3. Click **Start**. Your dataset is ready in seconds.

### 💼 Business use cases

**🎨 Asset discovery.** Find top LoRAs and checkpoints for your art pipeline.

**📊 Trend tracking.** Monitor how SDXL adoption compares to SD 1.5 by downloads.

**🏢 Internal galleries.** Mirror Civitai assets into a private discovery UI.

**📰 Gen-AI journalism.** Build datasets on community taste shifts.

### 🔌 Automating Civitai Public Models API Scraper

- **Make / Zapier**: schedule a daily run.
- **Cron schedule**: native Apify scheduler.
- **Webhooks**: POST on completion.
- **Warehouse pipe**: native integrations move datasets straight into BigQuery, Snowflake, or Postgres.

### 🌟 Beyond business use cases

**🎓 Education.** Curate generative art teaching sets.

**🧪 Personal research.** Track what styles the community is producing.

**🤝 Non-profit and open data.** Open generative-AI ecosystem maps.

**🧰 Tinkering and prototyping.** Power a Civitai discovery side project.

### 🤖 Ask an AI assistant about this scraper

Drop this README into ChatGPT, Claude, or any AI assistant and ask it to design a Civitai analytics pipeline. The input fields, schema, and examples above contain everything an LLM needs.

### ❓ Frequently Asked Questions

**❓ API key needed?** No. Set CIVITAI\_API\_KEY env var for higher rate limits.

**❓ Filter by type?** Yes, Checkpoint, LoRA, ControlNet, and more.

**❓ Filter by base model?** Yes.

**❓ NSFW handling?** Off by default. Set nsfw to true to include.

**❓ Pagination?** Yes, automatic cursor pagination.

**❓ Rate limits?** Generous public limits.

**❓ Excel export?** Yes, via the Apify dataset UI.

**❓ Schema stability?** Core fields are stable.

**❓ Scheduling?** Yes, via Apify scheduler.

**❓ Public data only?** Yes.

### 🔌 Integrate with any app

Apify ships native integrations with Make, Zapier, Slack, Discord, Google Drive, Google Sheets, Gmail, Airbyte, Keboola, Telegram, GitHub, and any REST API or webhook endpoint. Trigger runs from a calendar event, a form submission, a cron job, or pipe results straight into BigQuery, Snowflake, or a Postgres warehouse.

### 🔗 Recommended Actors

| Actor | What it does |
|---|---|
| [ParseForge Hugging Face Spaces Scraper](https://apify.com/parseforge/huggingface-spaces-scraper) | Public Hugging Face Spaces metadata. |
| [ParseForge Hugging Face Collections Scraper](https://apify.com/parseforge/huggingface-collections-scraper) | Public Hugging Face collections. |
| [ParseForge Hugging Face Discussions Scraper](https://apify.com/parseforge/huggingface-discussions-scraper) | Discussion threads and PRs on Hugging Face repos. |
| [ParseForge ModelScope Models Scraper](https://apify.com/parseforge/modelscope-models-scraper) | ModelScope public models. |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for 900+ production-grade scrapers across business intelligence, real estate, e-commerce, sports, finance, and public records.

***

**Disclaimer.** This actor scrapes only publicly available data. ParseForge is not affiliated with, endorsed by, or sponsored by any of the third-party services referenced. Users are responsible for complying with the target site's terms of service and applicable law. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp).

# Actor input Schema

## `query` (type: `string`):

Free-text search across Civitai model names. Trimmed before being sent to the API.

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

Free users are limited to 10 items (preview). Paid users can collect up to 1,000,000 items.

## `sort` (type: `string`):

Sort order for the API.

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

Civitai model type filter.

## `baseModel` (type: `string`):

Filter by base model (e.g. SD 1.5, SDXL 1.0, Pony, Flux.1 D).

## `nsfw` (type: `boolean`):

When true, include NSFW models. When false (default), only safe-for-work models are returned.

## Actor input object example

```json
{
  "maxItems": 10,
  "sort": "Highest Rated",
  "nsfw": false
}
```

# Actor output Schema

## `results` (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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/civitai-models-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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/civitai-models-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 '{
  "maxItems": 10
}' |
apify call parseforge/civitai-models-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Civitai Models Scraper",
        "description": "Query the Civitai catalog of community Stable Diffusion models. Records include id, name, type, creator, downloads, favorites, rating, base model, tags, NSFW flag, size, and URL. Useful for AI art research, model curation, and tracking trends across community submissions.",
        "version": "0.1",
        "x-build-id": "X6bnRuzDVvhOxrMwj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~civitai-models-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-civitai-models-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/parseforge~civitai-models-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-civitai-models-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/parseforge~civitai-models-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-civitai-models-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": {
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text search across Civitai model names. Trimmed before being sent to the API."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users are limited to 10 items (preview). Paid users can collect up to 1,000,000 items."
                    },
                    "sort": {
                        "title": "Sort by",
                        "enum": [
                            "Highest Rated",
                            "Most Downloaded",
                            "Newest"
                        ],
                        "type": "string",
                        "description": "Sort order for the API.",
                        "default": "Highest Rated"
                    },
                    "type": {
                        "title": "Type",
                        "enum": [
                            "Checkpoint",
                            "TextualInversion",
                            "Hypernetwork",
                            "AestheticGradient",
                            "LORA",
                            "LoCon",
                            "Controlnet",
                            "Upscaler",
                            "MotionModule",
                            "VAE",
                            "Poses",
                            "Wildcards",
                            "Workflows",
                            "Other"
                        ],
                        "type": "string",
                        "description": "Civitai model type filter."
                    },
                    "baseModel": {
                        "title": "Base model",
                        "type": "string",
                        "description": "Filter by base model (e.g. SD 1.5, SDXL 1.0, Pony, Flux.1 D)."
                    },
                    "nsfw": {
                        "title": "Allow NSFW",
                        "type": "boolean",
                        "description": "When true, include NSFW models. When false (default), only safe-for-work models are returned.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```