# Civitai Models & Creators Scraper (`crawlerbros/civitai-scraper`) Actor

Scrape Civitai, the largest AI art model sharing platform. Search AI models (Checkpoints, LoRAs, ControlNets), browse creators, collect generated images with full metadata, and explore tags. Supports cursor-based pagination for large result sets

- **URL**: https://apify.com/crawlerbros/civitai-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** AI, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 7 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Civitai Models & Creators Scraper

> Search and extract AI models, creators, generated images, and tags from Civitai — the world's largest open AI art model sharing platform.

### What does this actor do?

Civitai hosts hundreds of thousands of community-trained AI models including Stable Diffusion Checkpoints, LoRAs, ControlNets, Embeddings, and more. This actor lets you:

- **Search AI models** by keyword, type, rating, and time period
- **Browse creators** and their published model counts
- **Collect generated images** with full generation metadata (prompt, seed, sampler, CFG scale)
- **List tags** used to categorize models on the platform
- **Fetch specific models** by ID or Civitai URL
- **Get all models by a creator** username

Data is fetched directly from the official Civitai REST API using cursor-based pagination to reliably retrieve large result sets.

### Input

| Field | Type | Description | Default |
|-------|------|-------------|---------|
| `mode` | Select | What to fetch: `searchModels`, `searchCreators`, `searchImages`, `getTags`, `getModel`, `byUser` | `searchModels` |
| `searchQuery` | Text | Free-text search query | — |
| `modelIds` | String List | Model IDs for direct lookup (`mode=getModel`) | — |
| `startUrls` | String List | Civitai model URLs for direct lookup (`mode=getModel`) | — |
| `username` | Text | Creator username for `mode=byUser` or image filter | — |
| `modelType` | Select | Filter by type: Checkpoint, LORA, ControlNet, VAE, etc. | — |
| `sortBy` | Select | Sort order: `Highest Rated`, `Most Downloaded`, `Newest` | `Newest` |
| `period` | Select | Time period: `AllTime`, `Year`, `Month`, `Week`, `Day` | `AllTime` |
| `nsfwAllowed` | Boolean | Include NSFW content in results | `false` |
| `minRating` | Number | Minimum average rating (0–5) | — |
| `maxItems` | Integer | Maximum number of records to emit (1–5000) | `50` |
| `apiToken` | Secret | Optional Civitai API token for higher rate limits | — |

### Output

#### Model record

| Field | Type | Description |
|-------|------|-------------|
| `modelId` | Integer | Unique Civitai model ID |
| `name` | String | Model name |
| `type` | String | Model type (Checkpoint, LORA, etc.) |
| `nsfw` | Boolean | Whether the model is marked NSFW |
| `rating` | Float | Average community rating (0–5) |
| `ratingCount` | Integer | Number of ratings |
| `downloadCount` | Integer | Total number of downloads |
| `favoriteCount` | Integer | Total favorites |
| `commentCount` | Integer | Total comments |
| `tags` | Array | List of tag strings |
| `creator` | Object | Creator `username` and `image` URL |
| `versions` | Array | Model versions with download URLs and preview images |
| `url` | String | Direct Civitai URL for the model |
| `recordType` | String | Always `"model"` |
| `scrapedAt` | String | ISO 8601 timestamp of extraction |

#### Creator record

| Field | Type | Description |
|-------|------|-------------|
| `username` | String | Civitai username |
| `avatarUrl` | String | Profile image URL |
| `modelCount` | Integer | Number of published models |
| `url` | String | Profile page URL |
| `recordType` | String | Always `"creator"` |
| `scrapedAt` | String | ISO 8601 timestamp |

#### Image record

| Field | Type | Description |
|-------|------|-------------|
| `imageId` | Integer | Unique image ID |
| `url` | String | Direct image URL |
| `nsfw` | String | NSFW level: `None`, `Soft`, `Mature`, `X` |
| `width` | Integer | Image width in pixels |
| `height` | Integer | Image height in pixels |
| `meta` | Object | Generation metadata: prompt, seed, steps, sampler, cfgScale |
| `stats` | Object | Reaction counts: likeCount, heartCount, etc. |
| `username` | String | Creator username |
| `recordType` | String | Always `"image"` |
| `scrapedAt` | String | ISO 8601 timestamp |

### Example output record

```json
{
  "modelId": 12345,
  "name": "Ultra Realistic Portrait v2",
  "type": "Checkpoint",
  "nsfw": false,
  "rating": 4.87,
  "ratingCount": 512,
  "downloadCount": 198000,
  "favoriteCount": 5400,
  "commentCount": 220,
  "tags": ["portrait", "realistic", "photography"],
  "creator": {
    "username": "portrait_master",
    "image": "https://image.civitai.com/avatar.jpg"
  },
  "versions": [
    {
      "id": 67890,
      "name": "v2.0",
      "baseModel": "SD 1.5",
      "downloadUrl": "https://civitai.com/api/download/models/67890",
      "images": ["https://image.civitai.com/img1.jpg"]
    }
  ],
  "url": "https://civitai.com/models/12345",
  "recordType": "model",
  "scrapedAt": "2026-05-17T12:00:00+00:00"
}
````

### FAQ

**Do I need an API token?**
No. The Civitai API is publicly accessible without authentication. An optional API token from civitai.com/user/account increases your rate limits and may be required to access NSFW content above the default threshold.

**How many results can I get?**
Up to 5,000 records per run using `maxItems`. The actor uses cursor-based pagination to retrieve all available results beyond the first page.

**How fresh is the data?**
Data is fetched live from the Civitai API at the time of the actor run. Model download counts and ratings reflect the state at that moment.

**Can I fetch a specific model I know the URL for?**
Yes. Use `mode=getModel` and provide either the Civitai model URL (e.g. `https://civitai.com/models/12345`) or just the numeric ID in `modelIds`.

**Why are some NSFW models not appearing?**
By default `nsfwAllowed` is `false`. Enable it to include NSFW content. For full NSFW access, provide an API token from a Civitai account with NSFW permissions enabled.

**What model types are supported?**
All Civitai model types: Checkpoint, TextualInversion (Embedding), Hypernetwork, AestheticGradient, LORA, LoCon, ControlNet, Upscaler, MotionModule, VAE, Poses, Wildcards, Workflows, and Other.

**Can I get all models by a specific creator?**
Yes. Use `mode=byUser` and set `username` to the creator's Civitai username.

### Limitations

- The Civitai API enforces rate limits on unauthenticated requests. Providing an API token increases the allowed request rate.
- Model file weights and binary data are not downloaded — only metadata and preview image URLs are extracted.
- Some NSFW content requires both `nsfwAllowed=true` and a valid API token from an account with appropriate settings.
- The `versions[].downloadUrl` links point to the Civitai CDN. Downloading model files requires a Civitai account in some cases.

# Actor input Schema

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

What to fetch from Civitai.

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

Free-text search query (used in searchModels, searchCreators, searchImages, getTags modes).

## `modelIds` (type: `array`):

Civitai model IDs (e.g. `12345`) for direct lookup.

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

Civitai model URLs like `https://civitai.com/models/12345` for direct lookup.

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

Fetch all models by this creator. Also used as a filter in searchImages mode.

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

Filter results to a specific model type.

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

Sort order for search results.

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

Time window for sorting (applies to Highest Rated and Most Downloaded sorts).

## `nsfwAllowed` (type: `boolean`):

When enabled, include NSFW models and images. Requires an API token for full NSFW access.

## `minRating` (type: `number`):

Only include models with an average rating at or above this value (0–5).

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

Maximum number of records to emit across all pages.

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

Optional API token from civitai.com/user/account. Increases rate limits and enables full NSFW access.

## Actor input object example

```json
{
  "mode": "searchModels",
  "searchQuery": "realistic portrait",
  "modelIds": [],
  "startUrls": [],
  "sortBy": "Newest",
  "period": "AllTime",
  "nsfwAllowed": false,
  "maxItems": 50
}
```

# Actor output Schema

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

Dataset containing all scraped Civitai records (models, creators, images, or tags depending on mode).

# 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 = {
    "mode": "searchModels",
    "searchQuery": "realistic portrait",
    "modelIds": [],
    "startUrls": [],
    "sortBy": "Newest",
    "period": "AllTime",
    "nsfwAllowed": false,
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/civitai-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 = {
    "mode": "searchModels",
    "searchQuery": "realistic portrait",
    "modelIds": [],
    "startUrls": [],
    "sortBy": "Newest",
    "period": "AllTime",
    "nsfwAllowed": False,
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/civitai-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 '{
  "mode": "searchModels",
  "searchQuery": "realistic portrait",
  "modelIds": [],
  "startUrls": [],
  "sortBy": "Newest",
  "period": "AllTime",
  "nsfwAllowed": false,
  "maxItems": 50
}' |
apify call crawlerbros/civitai-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Civitai Models & Creators Scraper",
        "description": "Scrape Civitai, the largest AI art model sharing platform. Search AI models (Checkpoints, LoRAs, ControlNets), browse creators, collect generated images with full metadata, and explore tags. Supports cursor-based pagination for large result sets",
        "version": "1.0",
        "x-build-id": "CpKumkPVzYmsenpin"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~civitai-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-civitai-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/crawlerbros~civitai-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-civitai-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/crawlerbros~civitai-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-civitai-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "searchModels",
                            "searchCreators",
                            "searchImages",
                            "getTags",
                            "getModel",
                            "byUser"
                        ],
                        "type": "string",
                        "description": "What to fetch from Civitai.",
                        "default": "searchModels"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text search query (used in searchModels, searchCreators, searchImages, getTags modes).",
                        "default": "realistic portrait"
                    },
                    "modelIds": {
                        "title": "Model IDs (mode=getModel)",
                        "type": "array",
                        "description": "Civitai model IDs (e.g. `12345`) for direct lookup.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs (mode=getModel)",
                        "type": "array",
                        "description": "Civitai model URLs like `https://civitai.com/models/12345` for direct lookup.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "username": {
                        "title": "Creator username (mode=byUser)",
                        "type": "string",
                        "description": "Fetch all models by this creator. Also used as a filter in searchImages mode."
                    },
                    "modelType": {
                        "title": "Model type filter",
                        "enum": [
                            "Checkpoint",
                            "TextualInversion",
                            "Hypernetwork",
                            "AestheticGradient",
                            "LORA",
                            "LoCon",
                            "Controlnet",
                            "Upscaler",
                            "MotionModule",
                            "VAE",
                            "Poses",
                            "Wildcards",
                            "Workflows",
                            "Other"
                        ],
                        "type": "string",
                        "description": "Filter results to a specific model type."
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "Highest Rated",
                            "Most Downloaded",
                            "Newest"
                        ],
                        "type": "string",
                        "description": "Sort order for search results.",
                        "default": "Newest"
                    },
                    "period": {
                        "title": "Time period",
                        "enum": [
                            "AllTime",
                            "Year",
                            "Month",
                            "Week",
                            "Day"
                        ],
                        "type": "string",
                        "description": "Time window for sorting (applies to Highest Rated and Most Downloaded sorts).",
                        "default": "AllTime"
                    },
                    "nsfwAllowed": {
                        "title": "Include NSFW content",
                        "type": "boolean",
                        "description": "When enabled, include NSFW models and images. Requires an API token for full NSFW access.",
                        "default": false
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Only include models with an average rating at or above this value (0–5)."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of records to emit across all pages.",
                        "default": 50
                    },
                    "apiToken": {
                        "title": "Civitai API token (optional)",
                        "type": "string",
                        "description": "Optional API token from civitai.com/user/account. Increases rate limits and enables full NSFW access."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
