# Twitter Communities Top Posts Scraper (`automation-lab/twitter-communities-top-posts-scraper`) Actor

Scrape public X/Twitter Community posts with author, engagement, media, link, hashtag, and source community fields. Monitor niche community discussions.

- **URL**: https://apify.com/automation-lab/twitter-communities-top-posts-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Twitter Communities Top Posts Scraper

Extract public posts from X/Twitter Communities by community URL or ID. Use it to monitor ranked community discussions, collect post engagement, identify active authors, and export community-scoped social intelligence from Apify.

### What does Twitter Communities Top Posts Scraper do?

Twitter Communities Top Posts Scraper collects public post rows from X/Twitter Community pages.

It returns post text, author details, timestamps, engagement counts, media URLs, outbound links, hashtags, and the source community for every saved item.

The actor focuses on community-scoped feeds instead of broad keyword search. Give it one or more Community URLs and it extracts posts from those communities.

### Who is it for?

- 🧭 Social listening teams tracking niche X communities
- 📈 Growth marketers looking for community topic ideas
- 🧑‍💼 Community managers monitoring active authors and conversations
- 🧪 Researchers measuring engagement in specialized public groups
- 🧲 Lead generation teams finding people discussing a domain-specific problem

### Why use it?

X search and trend scraping are broad. Communities are different because the audience and context are pre-filtered by a group.

Use this actor when you already know the communities you care about and need structured post data from those exact spaces.

### Data you can extract

| Field group | Examples |
| --- | --- |
| Community | community ID, URL, name, description, sort mode |
| Post | post ID, URL, text, language, creation time |
| Author | username, display name, profile URL, avatar, verification flag |
| Engagement | replies, reposts, likes, quotes, bookmarks, views, total engagement |
| Content enrichments | hashtags, cashtags, media URLs, outbound links |
| Run metadata | scraped timestamp |

### How much does it cost to scrape Twitter Community posts?

The actor uses pay-per-event pricing.

- A small start event is charged once per run.
- A per-item event is charged for each community post saved.
- Tier discounts reduce the per-post price for higher-volume users.

Use a low `maxItems` value for your first run, then increase it once you confirm the community produces the data you need.

### Input

The main input is `communityUrls`.

```json
{
  "communityUrls": [
    { "url": "https://x.com/i/communities/1493446837214187523" }
  ],
  "maxItems": 20,
  "sortMode": "top"
}
````

You can also provide numeric `communityIds` if your workflow stores IDs already.

### Output

Each dataset row is one post from a public X/Twitter Community.

```json
{
  "communityId": "1493446837214187523",
  "communityUrl": "https://x.com/i/communities/1493446837214187523",
  "communityName": "Build in Public",
  "sortMode": "top",
  "postId": "1234567890",
  "postUrl": "https://x.com/example/status/1234567890",
  "text": "Example community post text",
  "authorUsername": "example",
  "likeCount": 42,
  "repostCount": 5,
  "replyCount": 3,
  "urls": [],
  "mediaUrls": [],
  "scrapedAt": "2026-06-20T22:00:00.000Z"
}
```

### How to scrape top posts from an X Community

1. Open a public Community on X/Twitter.
2. Copy the URL from your browser.
3. Paste it into `communityUrls`.
4. Set `maxItems` to a small number for a test run.
5. Choose `top` for ranked posts or `latest` for the logged-out latest feed.
6. Start the actor.
7. Export the dataset as JSON, CSV, Excel, or through the Apify API.

### Sort modes

`top` uses X's ranked logged-out community timeline and is best for popular or high-engagement posts.

`latest` uses the public logged-out community timeline when X exposes it. Some communities may show limited content in latest mode to logged-out users.

### Tips for best results

- Start with 10-20 posts to verify the community is public and active.
- Use `top` for market research and lead discovery.
- Use `latest` when you need recency monitoring.
- Increase `requestDelayMs` if X starts returning transient errors.
- Use proxy settings only when your network is blocked.

### Integrations

Use the actor in workflows such as:

- Send new top community posts to Slack for a social listening digest.
- Export posts to Google Sheets for manual qualification.
- Feed author usernames into a CRM enrichment workflow.
- Store community posts in a data warehouse for trend analysis.
- Trigger alerts when posts contain competitor names or product keywords.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/twitter-communities-top-posts-scraper').call({
  communityUrls: [{ url: 'https://x.com/i/communities/1493446837214187523' }],
  maxItems: 20,
  sortMode: 'top',
});

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

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/twitter-communities-top-posts-scraper').call(run_input={
    'communityUrls': [{'url': 'https://x.com/i/communities/1493446837214187523'}],
    'maxItems': 20,
    'sortMode': 'top',
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~twitter-communities-top-posts-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"communityUrls":[{"url":"https://x.com/i/communities/1493446837214187523"}],"maxItems":20,"sortMode":"top"}'
```

### MCP integration

Use the actor from Claude Desktop, Claude Code, or other MCP clients through Apify MCP Server.

MCP server URL:

```text
https://mcp.apify.com/?tools=automation-lab/twitter-communities-top-posts-scraper
```

Claude Code setup:

```bash
claude mcp add apify-twitter-communities "https://mcp.apify.com/?tools=automation-lab/twitter-communities-top-posts-scraper"
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-twitter-communities": {
      "url": "https://mcp.apify.com/?tools=automation-lab/twitter-communities-top-posts-scraper"
    }
  }
}
```

Example prompts:

- "Scrape the top 20 posts from this X Community and summarize repeated pain points."
- "Find authors with high engagement in this Twitter Community."
- "Export media links from recent posts in this Community."

### Proxy settings

The actor works without a proxy for public guest endpoints in normal conditions.

If X blocks direct access from your environment, enable Apify Proxy and start with a small run. Datacenter proxies should be tried before residential proxies to control cost.

### Limitations

- Private or members-only communities may not expose full content to logged-out users.
- X can change web GraphQL operation IDs or guest-token behavior.
- Deleted, tombstoned, or unavailable posts are skipped.
- Engagement counts reflect what X returns at scrape time.

### FAQ

#### Why did my run return fewer posts than maxItems?

The public logged-out feed may expose fewer posts than requested, the community may be inactive, or X may stop pagination early.

#### Why do I see an unavailable-community error?

Check that the URL is a public X/Twitter Community URL and that the numeric ID is correct.

#### Should I use residential proxy?

Only after direct access and cheaper datacenter proxy access fail. Residential proxy traffic is much more expensive.

### Related scrapers

- [Twitter/X Scraper](https://apify.com/automation-lab/twitter-scraper) for broad tweet, profile, and search extraction.
- [Twitter/X Trends Scraper](https://apify.com/automation-lab/twitter-trends-scraper) for trend monitoring.
- [Twitter Followers Scraper](https://apify.com/automation-lab/twitter-followers-scraper) for follower/following lists.

### Legality

This actor extracts public web data returned by X/Twitter to logged-out web clients. You are responsible for using the data lawfully, respecting privacy, following X's terms, and complying with applicable laws in your jurisdiction.

### Changelog

Initial version extracts public ranked/latest community post rows with author, engagement, media, link, hashtag, and community context fields.

### Support

If a public community fails, include the community URL, input JSON, run ID, and a short description of what you expected to extract.

### Example workflow: social listening

1. Maintain a list of important X Communities.
2. Run this actor every morning with `sortMode` set to `top`.
3. Filter posts with high engagement.
4. Send promising posts to a researcher or salesperson.
5. Track repeated keywords over time.

### Example workflow: content research

1. Scrape top posts from niche communities.
2. Group posts by hashtags and outbound links.
3. Review highly liked posts for topic ideas.
4. Turn repeated questions into blog posts, videos, or product documentation.

### Example workflow: author discovery

1. Collect top community posts.
2. Sort by engagement count.
3. Deduplicate by `authorUsername`.
4. Review author profiles manually or with another enrichment actor.
5. Save qualified accounts for outreach.

# Actor input Schema

## `communityUrls` (type: `array`):

Public X/Twitter Community URLs, for example https://x.com/i/communities/1493446837214187523.

## `communityIds` (type: `array`):

Optional numeric community IDs. Use this when you already store IDs instead of URLs.

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

Total maximum number of post rows to save across all communities.

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

Use top for the ranked community feed or latest for the logged-out latest feed when X exposes it.

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

Delay between X API calls. Increase this for larger runs if X starts rate limiting.

## `proxyConfiguration` (type: `object`):

Optional Apify Proxy settings. Leave disabled unless X blocks direct access for your run.

## Actor input object example

```json
{
  "communityUrls": [
    {
      "url": "https://x.com/i/communities/1493446837214187523"
    }
  ],
  "communityIds": [],
  "maxItems": 20,
  "sortMode": "top",
  "requestDelayMs": 1200,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "communityUrls": [
        {
            "url": "https://x.com/i/communities/1493446837214187523"
        }
    ],
    "communityIds": [],
    "maxItems": 20,
    "sortMode": "top",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/twitter-communities-top-posts-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 = {
    "communityUrls": [{ "url": "https://x.com/i/communities/1493446837214187523" }],
    "communityIds": [],
    "maxItems": 20,
    "sortMode": "top",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/twitter-communities-top-posts-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 '{
  "communityUrls": [
    {
      "url": "https://x.com/i/communities/1493446837214187523"
    }
  ],
  "communityIds": [],
  "maxItems": 20,
  "sortMode": "top",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/twitter-communities-top-posts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Twitter Communities Top Posts Scraper",
        "description": "Scrape public X/Twitter Community posts with author, engagement, media, link, hashtag, and source community fields. Monitor niche community discussions.",
        "version": "0.1",
        "x-build-id": "b5aWKMPCiU5mZqQUJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~twitter-communities-top-posts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-twitter-communities-top-posts-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~twitter-communities-top-posts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-twitter-communities-top-posts-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~twitter-communities-top-posts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-twitter-communities-top-posts-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "communityUrls": {
                        "title": "Community URLs",
                        "type": "array",
                        "description": "Public X/Twitter Community URLs, for example https://x.com/i/communities/1493446837214187523.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "communityIds": {
                        "title": "Community IDs",
                        "type": "array",
                        "description": "Optional numeric community IDs. Use this when you already store IDs instead of URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum posts",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Total maximum number of post rows to save across all communities.",
                        "default": 50
                    },
                    "sortMode": {
                        "title": "Post ordering",
                        "enum": [
                            "top",
                            "latest"
                        ],
                        "type": "string",
                        "description": "Use top for the ranked community feed or latest for the logged-out latest feed when X exposes it.",
                        "default": "top"
                    },
                    "requestDelayMs": {
                        "title": "Request delay in milliseconds",
                        "minimum": 500,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Delay between X API calls. Increase this for larger runs if X starts rate limiting.",
                        "default": 1200
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy settings. Leave disabled unless X blocks direct access for your run."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```