# Bluesky Profile Feed Scraper (`fetch_cat/bluesky-profile-feed-scraper`) Actor

Extract public Bluesky profile metadata and recent posts from handles or DIDs. Export author feeds, engagement counts, timestamps, and URLs.

- **URL**: https://apify.com/fetch\_cat/bluesky-profile-feed-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.03 / 1,000 result extracteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Bluesky Profile Feed Scraper

Extract public Bluesky profile metadata and recent public author-feed posts from handles or DIDs.

### What does Bluesky Profile Feed Scraper do?

Bluesky Profile Feed Scraper collects public account details and recent public posts from Bluesky.

Use it when you need a clean dataset of profile fields, post text, engagement counts, timestamps, labels, embeds, and canonical Bluesky URLs.

It accepts handles such as `bsky.app` and DIDs such as `did:plc:z72i7hdynmk6r22z27h6tvur`.

No Bluesky login is required for public profiles and public author feeds.

### Who is it for?

Marketing teams can monitor brand accounts and creator activity.

Social researchers can collect public post samples for trend analysis.

Developer relations teams can export public updates from ecosystem accounts.

Journalists can archive public posts from official organizations.

Data teams can feed profile and post records into warehouses, dashboards, or enrichment pipelines.

### Why use this actor?

🦋 Handle and DID input support.

🦋 Profile metadata and posts in one dataset.

🦋 Cursor pagination for recent author feeds.

🦋 Optional reply and repost filters.

🦋 Public-data workflow without account credentials.

🦋 Lightweight HTTP collection for fast runs.

### Data returned

| Field | Description |
| --- | --- |
| `recordType` | `profile` or `post` |
| `inputActor` | Handle or DID from your input |
| `actorDid` | Profile DID |
| `actorHandle` | Current profile handle |
| `profileDisplayName` | Display name when available |
| `profileDescription` | Profile bio |
| `profileAvatar` | Avatar URL |
| `followersCount` | Public follower count |
| `followsCount` | Public following count |
| `postsCount` | Public post count |
| `uri` | AT Protocol post URI |
| `cid` | Post content ID |
| `url` | Browser URL for profile or post |
| `text` | Post text |
| `createdAt` | Post creation timestamp |
| `indexedAt` | Bluesky indexing timestamp |
| `replyCount` | Reply count |
| `repostCount` | Repost count |
| `likeCount` | Like count |
| `quoteCount` | Quote count |
| `bookmarkCount` | Bookmark count when returned |
| `authorHandle` | Post author handle |
| `authorDid` | Post author DID |
| `isReply` | Whether the post is a reply |
| `isRepost` | Whether the feed item is a repost |
| `replyParentUri` | Parent reply URI |
| `replyRootUri` | Root thread URI |
| `embed` | Embedded media/link object |
| `labels` | Public labels returned by Bluesky |

### How much does it cost to scrape Bluesky profile feeds?

The actor uses pay-per-event pricing.

A small start event is charged once per run.

Each saved profile or post is charged as one result.

The formula-derived BRONZE price is about $0.026 per 1,000 saved records before tier discounts.

Volume tiers reduce the per-record price for higher Apify plans.

### Input

```json
{
  "actors": ["bsky.app"],
  "maxPostsPerActor": 25,
  "includeReplies": false,
  "includeReposts": false
}
````

### Input fields

#### `actors`

List of public Bluesky handles or DIDs.

Examples:

- `bsky.app`
- `apify.com`
- `did:plc:z72i7hdynmk6r22z27h6tvur`

#### `maxPostsPerActor`

Maximum number of posts to save for each account after filters are applied.

Set it to `0` if you only need profile metadata.

#### `includeReplies`

Set to `true` to include replies.

Leave it `false` for a cleaner top-level-post dataset.

#### `includeReposts`

Set to `true` to include reposted feed items.

Leave it `false` to focus on original account posts.

#### `requestDelayMs`

Optional delay between feed pages.

Increase it for very large jobs if you want a gentler request pace.

### Output example

```json
{
  "recordType": "post",
  "inputActor": "bsky.app",
  "actorDid": "did:plc:z72i7hdynmk6r22z27h6tvur",
  "actorHandle": "bsky.app",
  "profileDisplayName": "Bluesky",
  "url": "https://bsky.app/profile/bsky.app/post/example",
  "text": "Public post text",
  "createdAt": "2026-06-25T19:03:39.125Z",
  "replyCount": 10,
  "repostCount": 20,
  "likeCount": 100,
  "authorHandle": "bsky.app",
  "authorDid": "did:plc:z72i7hdynmk6r22z27h6tvur",
  "isReply": false,
  "isRepost": false
}
```

### How to scrape Bluesky profiles

1. Open the actor.

2. Add one or more handles or DIDs.

3. Choose how many posts to collect per account.

4. Decide whether replies or reposts should be included.

5. Start the run.

6. Export the dataset as JSON, CSV, Excel, XML, or RSS from Apify.

### Tips for better results

Use handles for readability and DIDs when you need stable account identifiers.

Keep the first test run small.

Use `includeReplies: false` when you want only account-originated announcements.

Use `includeReposts: true` when you want the full author feed context.

For monitoring workflows, run the actor on a schedule and deduplicate by `uri`.

### Common workflows

🦋 Export posts from official accounts.

🦋 Monitor product announcements.

🦋 Build a creator-account watchlist.

🦋 Enrich CRM records with public Bluesky profile metrics.

🦋 Archive public posts for research review.

### Integrations

Send results to Google Sheets for lightweight reporting.

Use webhooks to notify Slack when a scheduled run finishes.

Load JSON output into BigQuery, Snowflake, or Postgres.

Connect the actor to n8n or Make for social-monitoring workflows.

Use Apify datasets as the source for downstream AI summarization.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/bluesky-profile-feed-scraper').call({
  actors: ['bsky.app'],
  maxPostsPerActor: 25,
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('fetch_cat/bluesky-profile-feed-scraper').call(run_input={
    'actors': ['bsky.app'],
    'maxPostsPerActor': 25,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~bluesky-profile-feed-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"actors":["bsky.app"],"maxPostsPerActor":25}'
```

### MCP usage

You can use this actor from MCP-compatible tools through Apify MCP.

Claude Code setup:

```bash
claude mcp add apify https://mcp.apify.com/?tools=fetch_cat/bluesky-profile-feed-scraper
```

Claude Desktop JSON example:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/bluesky-profile-feed-scraper"
    }
  }
}
```

Example prompts:

- "Run the Bluesky Profile Feed Scraper for `bsky.app` and summarize the last 20 posts."
- "Collect profile metrics for these Bluesky handles and return a table."
- "Find which recent posts from this account had the highest engagement."

### Scheduling

Schedule daily or hourly runs for monitoring public accounts.

Use low limits for frequent runs.

Use a larger limit for initial backfills.

Deduplicate downstream by `uri` for posts and `actorDid` for profiles.

### Limits

Only public Bluesky data is returned.

Private or unavailable accounts cannot be collected.

Deleted posts may disappear from future runs.

Large account lists take longer because each profile has its own paginated feed.

The actor skips invalid accounts when at least one valid account is provided.

### Legality and responsible use

This actor collects publicly available data.

You are responsible for using the results lawfully and respecting applicable privacy, copyright, platform, and data-protection rules.

Do not use scraped data for spam, harassment, impersonation, or prohibited profiling.

If you store personal data, apply appropriate retention and deletion policies.

### Troubleshooting

#### Why did a handle return no records?

The handle may be invalid, renamed, deleted, or temporarily unavailable.

Try the current handle in a browser or use the account DID.

#### Why are replies missing?

Replies are excluded by default.

Set `includeReplies` to `true` to collect replies.

#### Why are reposts missing?

Reposts are excluded by default.

Set `includeReposts` to `true` to collect repost feed items.

#### Why is the post count lower than requested?

Filters are applied after reading author-feed pages.

If an account mostly posts replies or reposts and those are excluded, fewer records may be saved.

### FAQ

#### Does this require a Bluesky account?

No. It works with public profile and author-feed data.

#### Can I scrape multiple accounts?

Yes. Add multiple handles or DIDs to the `actors` array.

#### Can I get only profile metadata?

Yes. Set `maxPostsPerActor` to `0`.

#### Can I monitor accounts over time?

Yes. Schedule the actor and deduplicate posts by `uri`.

#### Does it return images and embeds?

It returns the public embed object when Bluesky includes it in the feed response.

### Related scrapers

- [YouTube Channel Videos Scraper](https://apify.com/fetch_cat/youtube-channel-videos-scraper)
- [YouTube Channel Details Scraper](https://apify.com/fetch_cat/youtube-channel-details-scraper)
- [TikTok Comments Scraper](https://apify.com/fetch_cat/tiktok-comments-scraper)
- [Reddit Scraper](https://apify.com/fetch_cat/reddit-scraper)
- [Product Hunt Scraper](https://apify.com/fetch_cat/product-hunt-scraper)

### Changelog

#### 0.1

Initial version with profile extraction, author-feed pagination, reply filtering, repost filtering, handle input, and DID input.

### Support

If a run fails, include the run ID, input, and expected account handles when asking for help.

Small reproducible examples are the fastest way to diagnose invalid handles, missing records, or changed upstream behavior.

# Actor input Schema

## `actors` (type: `array`):

Public Bluesky handles or decentralized identifiers to scrape. Examples: bsky.app, apify.com, did:plc:z72i7hdynmk6r22z27h6tvur

## `maxPostsPerActor` (type: `integer`):

How many author-feed posts to save for each account after reply/repost filters are applied.

## `includeReplies` (type: `boolean`):

Save replies in addition to top-level posts.

## `includeReposts` (type: `boolean`):

Save reposted posts that appear in the author feed.

## `requestDelayMs` (type: `integer`):

Optional delay between paginated API requests. Increase if you are collecting many posts from many accounts.

## Actor input object example

```json
{
  "actors": [
    "bsky.app"
  ],
  "maxPostsPerActor": 20,
  "includeReplies": false,
  "includeReposts": false,
  "requestDelayMs": 150
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "actors": [
        "bsky.app"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/bluesky-profile-feed-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 = { "actors": ["bsky.app"] }

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/bluesky-profile-feed-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 '{
  "actors": [
    "bsky.app"
  ]
}' |
apify call fetch_cat/bluesky-profile-feed-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bluesky Profile Feed Scraper",
        "description": "Extract public Bluesky profile metadata and recent posts from handles or DIDs. Export author feeds, engagement counts, timestamps, and URLs.",
        "version": "0.1",
        "x-build-id": "nJmFkq7TdHo9HQVMm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~bluesky-profile-feed-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-bluesky-profile-feed-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/fetch_cat~bluesky-profile-feed-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-bluesky-profile-feed-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/fetch_cat~bluesky-profile-feed-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-bluesky-profile-feed-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": [
                    "actors"
                ],
                "properties": {
                    "actors": {
                        "title": "Handles or DIDs",
                        "type": "array",
                        "description": "Public Bluesky handles or decentralized identifiers to scrape. Examples: bsky.app, apify.com, did:plc:z72i7hdynmk6r22z27h6tvur",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPostsPerActor": {
                        "title": "Maximum posts per account",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "How many author-feed posts to save for each account after reply/repost filters are applied.",
                        "default": 20
                    },
                    "includeReplies": {
                        "title": "Include replies",
                        "type": "boolean",
                        "description": "Save replies in addition to top-level posts.",
                        "default": false
                    },
                    "includeReposts": {
                        "title": "Include reposts",
                        "type": "boolean",
                        "description": "Save reposted posts that appear in the author feed.",
                        "default": false
                    },
                    "requestDelayMs": {
                        "title": "Delay between feed pages (ms)",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Optional delay between paginated API requests. Increase if you are collecting many posts from many accounts.",
                        "default": 150
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
