# Truth Social Scraper (it Worked) (`coder_luffy/truth-social-scraper`) Actor

Truth Social Scraper extracts real-time posts, replies, and interaction metrics directly from user profiles. It uses browser automation to intercept official network requests, easily bypassing standard anti-bot protections to deliver clean JSON data.

- **URL**: https://apify.com/coder\_luffy/truth-social-scraper.md
- **Developed by:** [Luffy](https://apify.com/coder_luffy) (community)
- **Categories:** Social media, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.99 / 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

![Truth Social Scraper Banner](https://i.imgur.com/N5o7y5V.png)

## Truth Social Scraper: Extract Posts, Media, Replies, and Engagement Data from truthsocial.com

The Truth Social scraper is a no-code data extraction tool for **truthsocial.com**. Point it at any public Truth Social profile and it returns clean, structured JSON: posts, replies, retruths, media attachments, follower counts, and per-post engagement numbers. No login required, no fragile CSS selectors, and no headless browser to babysit.

If you have tried to track what is posted on **truth social** at any real scale, you already know why this exists. The timeline is dynamic, and most generic scrapers either time out, get rate-limited into the ground, or hand back half-populated objects with missing media URLs. This actor handles all of that for you.

### What this Truth Social scraper actually does

You give it a list of usernames. It fetches the user's statuses, handling proper pagination, and writes every post to a dataset. You can cap how many posts per user, filter to media-only, exclude replies, or do the opposite and pull only replies. If a previous run died halfway, you can resume from a specific post ID instead of starting over.

The output is the raw, full-fat JSON object for each status. That includes the post ID, creation timestamp, visibility, language, and source URL. You get the full post HTML and a cleaned plain-text version. The complete account object comes along with each post: display name, bio, follower count, following count, total statuses, avatar and header image URLs, verified and premium flags. Every media attachment includes both the original and preview URLs plus its type (image, video, gifv). Counts for replies, retruths, favorites, upvotes, and downvotes are all there. Mentions, hashtags, and quote or reblog references show up when present.

You can keep the raw HTML `content` field, or strip it out with `cleanContent: true` and keep only the plain text. Handy if you are dumping into a database and do not want to deal with escaping later.

### Why scraping truthsocial.com is harder than it looks

A few things trip people up when they try to scrape **truth social** with a generic web scraper.

The site is a single-page app. The timeline you see in your browser is fetched via API after the page loads, so a basic HTTP GET of the profile URL returns almost no useful content. You need to either render JavaScript (slow, expensive) or hit the API directly (fast, but you need to know the patterns and handle the auth headers).

Account IDs are not the same as usernames. The URL says `@realDonaldTrump` but the API needs the numeric account ID, like `107780257626128497`. You have to resolve that first, and the resolution endpoint has its own rate limits.

Pagination uses `max_id` cursors, not page numbers. Handle this wrong and you either re-fetch the same page in a loop forever or skip entire chunks of history without noticing.

Rate limits are real and not always documented. Hammer the endpoint and you get capped, sometimes for hours. This scraper paces requests, retries with backoff, and rotates through Apify's proxy pool so long runs do not crater halfway through.

### Use cases for the Truth Social scraper

Anyone working with content from **truthsocial.com** at any real scale hits the same wall: you need the data in a usable format, not as screenshots or copy-pasted text. Here is where this scraper actually pays for itself.

> **🔬 Researchers & Academics**
> Track political messaging, run sentiment models, or study echo chambers. The full account object lets you weight posts by reach, ensuring a 12-million-follower account doesn't get the same weight as one with 200 followers. Assemble large public datasets cleanly.

> **📰 Journalists & Fact-Checkers**
> Pull exact posts from the API with verifiable timestamps and post IDs. If a public figure said something on **truthsocial.com**, you get a permanent record that survives even if the post is deleted later. Extract attached images to run reverse-image searches easily.

> **📈 Financial Markets & Hedge Funds**
> Watch statements from political figures and CEOs that move markets. Latency matters, and so does structured data you can pipe straight into your alerting systems and trading models.

> **🛡️ PR & Communications Teams**
> Watch for mentions of your company, executives, or products. Set up keyword alerts on replies to a client's account so your team finds out about negative sentiment spikes instantly.

> **📊 Social Media Analysts & Strategists**
> Build per-account engagement dashboards. Favorites, retruths, and reply counts are included in every response. See what content performs best (video vs. text, links vs. native) to inform editorial decisions.

> **💾 Archivists & Intelligence Teams**
> Drop the JSON output straight into Elasticsearch, Postgres, or a vector store. The `startPostId` parameter lets you do clean incremental backups without re-fetching the same data every time.

[![Try it now on Apify](https://i.imgur.com/FML0KGc.png)](https://apify.com/your-username/truth-social-scraper)

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `profiles` | array | `["realDonaldTrump"]` | List of Truth Social usernames to scrape. No `@` prefix needed. |
| `maxItemsPerProfile` | integer | `100` | Maximum number of posts to extract per profile. Set higher for backfills. |
| `onlyMedia` | boolean | `false` | Return only posts with at least one media attachment. |
| `onlyReplies` | boolean | `false` | Return only posts that are replies to other posts. |
| `excludeReplies` | boolean | `true` | Skip replies. Mutually exclusive with `onlyReplies`. |
| `cleanContent` | boolean | `false` | Drop the raw HTML `content` field and keep only `contentText`. |
| `startPostId` | string | `""` | Resume from a specific post ID. Useful for incremental scheduled runs. |

#### Example input

```json
{
    "profiles": ["realDonaldTrump", "KariLake"],
    "maxItemsPerProfile": 50,
    "onlyMedia": false,
    "excludeReplies": true,
    "cleanContent": true
}
````

This pulls the 50 most recent non-reply posts from both accounts, strips the HTML, and returns plain text plus all metadata.

### Output format

Each item in the dataset is one post. The schema mirrors the Truth Social API response one-to-one, with three extra convenience fields (`contentText`, `authorUsername`, `authorDisplayName`) added so you do not have to dig into the nested `account` object for the common cases.

```json
{
  "id": "116636418903333996",
  "created_at": "2026-05-25T17:35:13.050Z",
  "in_reply_to_id": null,
  "quote_id": null,
  "sensitive": false,
  "visibility": "public",
  "url": "https://truthsocial.com/@realDonaldTrump/116636418903333996",
  "account": {
    "id": "107780257626128497",
    "username": "realDonaldTrump",
    "acct": "realDonaldTrump",
    "display_name": "Donald J. Trump",
    "locked": false,
    "bot": false,
    "created_at": "2022-02-11T16:16:57.705Z",
    "url": "https://truthsocial.com/@realDonaldTrump",
    "avatar": "https://static-assets-1.truthsocial.com/.../454286ac07a6f6e6.jpeg",
    "header": "https://static-assets-1.truthsocial.com/.../ba3b910ba387bf4e.jpeg",
    "followers_count": 12700424,
    "following_count": 69,
    "statuses_count": 33786,
    "verified": true,
    "premium": true
  },
  "media_attachments": [
    {
      "id": "116636113195300888",
      "type": "image",
      "url": "https://static-assets-1.truthsocial.com/.../6bc73b77e61e7830.jpg",
      "preview_url": "https://static-assets-1.truthsocial.com/.../6bc73b77e61e7830.jpg"
    }
  ],
  "mentions": [],
  "tags": [],
  "replies_count": 1024,
  "reblogs_count": 2464,
  "favourites_count": 8283,
  "upvotes_count": 8283,
  "downvotes_count": 1,
  "contentText": "Example parsed plain text here",
  "authorUsername": "realDonaldTrump",
  "authorDisplayName": "Donald J. Trump"
}
```

![Output Sample](https://i.imgur.com/Il6v27j.png)

### How to run it

Three options, use whichever fits your workflow.

Run it on the Apify platform with no code. Open the actor page, paste your usernames into the input form, hit start. Results land in the default dataset and you can export to JSON, CSV, or Excel from the UI. Good for one-off pulls and for non-developers on the team.

Run it from Python. Install `apify-client`, drop in your API token, call `run` with the input dict, iterate the dataset. Five lines of real code. This is how you wire it into an existing data pipeline.

Run it from Node.js. Same idea on the JavaScript side: `npm install apify-client`, instantiate the client, call the actor, await the dataset. Works in any backend, serverless function, or scheduled job.

For ongoing collection, use Apify's built-in scheduler. Set it to every 30 minutes, every hour, or every day, whatever your use case needs. Pass the last seen `startPostId` between runs and you only fetch new posts each time.

### Legal and ethical notes

Public posts on **truthsocial.com** are, by definition, public. Scraping them for research, journalism, archival, or analytics is generally fine. How you use that data is on you. Do not use it to harass individuals, build surveillance products targeting private citizens, or break Truth Social's terms in ways that will get you banned. If you republish content, follow normal attribution and fair-use practices. If you are not sure whether your use case is acceptable, talk to a lawyer, not a scraper README.

# Actor input Schema

## `profiles` (type: `array`):

List of Truth Social usernames to scrape (e.g. realDonaldTrump).

## `maxItemsPerProfile` (type: `integer`):

Maximum number of posts (statuses) to extract per profile.

## `onlyMedia` (type: `boolean`):

If true, only fetch posts that contain media attachments.

## `onlyReplies` (type: `boolean`):

If true, only fetch posts that are replies to other posts.

## `excludeReplies` (type: `boolean`):

If true, exclude replies from the fetched posts.

## `excludeReblogs` (type: `boolean`):

If true, exclude retruths (shares) from the fetched posts.

## `pinned` (type: `boolean`):

If true, only fetch pinned posts.

## `cleanContent` (type: `boolean`):

If true, the raw HTML 'content' field will be removed from output, keeping only the plain 'contentText'.

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

An optional Post ID to start scraping from (acts as initial max\_id). Useful for resuming past runs.

## Actor input object example

```json
{
  "profiles": [
    "realDonaldTrump"
  ],
  "maxItemsPerProfile": 20,
  "onlyMedia": false,
  "onlyReplies": false,
  "excludeReplies": true,
  "excludeReblogs": false,
  "pinned": false,
  "cleanContent": false
}
```

# 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 = {
    "profiles": [
        "realDonaldTrump"
    ],
    "startPostId": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("coder_luffy/truth-social-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 = {
    "profiles": ["realDonaldTrump"],
    "startPostId": "",
}

# Run the Actor and wait for it to finish
run = client.actor("coder_luffy/truth-social-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 '{
  "profiles": [
    "realDonaldTrump"
  ],
  "startPostId": ""
}' |
apify call coder_luffy/truth-social-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Truth Social Scraper (it Worked)",
        "description": "Truth Social Scraper extracts real-time posts, replies, and interaction metrics directly from user profiles. It uses browser automation to intercept official network requests, easily bypassing standard anti-bot protections to deliver clean JSON data.",
        "version": "0.0",
        "x-build-id": "AtB9FTg2B14Hs1Veq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/coder_luffy~truth-social-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-coder_luffy-truth-social-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/coder_luffy~truth-social-scraper/runs": {
            "post": {
                "operationId": "runs-sync-coder_luffy-truth-social-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/coder_luffy~truth-social-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-coder_luffy-truth-social-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": [
                    "profiles"
                ],
                "properties": {
                    "profiles": {
                        "title": "Profile Usernames",
                        "type": "array",
                        "description": "List of Truth Social usernames to scrape (e.g. realDonaldTrump).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItemsPerProfile": {
                        "title": "Max Posts Per Profile",
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of posts (statuses) to extract per profile.",
                        "default": 20
                    },
                    "onlyMedia": {
                        "title": "Only Media",
                        "type": "boolean",
                        "description": "If true, only fetch posts that contain media attachments.",
                        "default": false
                    },
                    "onlyReplies": {
                        "title": "Only Replies",
                        "type": "boolean",
                        "description": "If true, only fetch posts that are replies to other posts.",
                        "default": false
                    },
                    "excludeReplies": {
                        "title": "Exclude Replies",
                        "type": "boolean",
                        "description": "If true, exclude replies from the fetched posts.",
                        "default": true
                    },
                    "excludeReblogs": {
                        "title": "Exclude Retruths",
                        "type": "boolean",
                        "description": "If true, exclude retruths (shares) from the fetched posts.",
                        "default": false
                    },
                    "pinned": {
                        "title": "Only Pinned",
                        "type": "boolean",
                        "description": "If true, only fetch pinned posts.",
                        "default": false
                    },
                    "cleanContent": {
                        "title": "Clean Content",
                        "type": "boolean",
                        "description": "If true, the raw HTML 'content' field will be removed from output, keeping only the plain 'contentText'.",
                        "default": false
                    },
                    "startPostId": {
                        "title": "Start Post ID (Optional)",
                        "type": "string",
                        "description": "An optional Post ID to start scraping from (acts as initial max_id). Useful for resuming past runs."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
