# Lemmy Scraper - Posts, Comments, Communities & Search (`claudethegoat/lemmy-fediverse-scraper`) Actor

Scrape Lemmy (any instance) via the official public REST API v3: a site-wide feed by sort/type, posts from named communities, recent comments, and full-text search over communities/posts/users/comments. Federated Reddit-alternative data, no credentials, no proxy required.

- **URL**: https://apify.com/claudethegoat/lemmy-fediverse-scraper.md
- **Developed by:** [Manik Anand](https://apify.com/claudethegoat) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 result scrapeds

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

## Lemmy Scraper — Posts, Comments, Communities & Users (Fediverse / Reddit Alternative)

**Scrape any Lemmy instance — posts, comments, communities, and users — in one run, with no account, no API key, and no proxy spend.** Point it at `lemmy.world` (the largest instance) or any other Lemmy server and export clean, structured JSON/CSV/Excel ready for analysis, dashboards, or AI pipelines.

Lemmy is the open-source, **federated Reddit alternative** built on ActivityPub. `lemmy.world` alone hosts **13,400+ communities, 735,000+ posts, and 6.7 million+ comments** (live count, July 2026) — a large, fully public, keyless corpus that most scrapers on the market don't touch.

### What it does — four modes, one actor

- **Feed** — a site-wide post feed by sort (`Active` / `Hot` / `New` / `TopDay` / `TopWeek` …) and listing type (`All` = the whole federated feed the instance sees, or `Local` only)
- **Community** — pull posts from any named community (e.g. `technology` or `selfhosted@lemmy.world`), across many communities in a single run
- **Comments** — recent comments site-wide or scoped to specific communities, with a `path` field for thread reconstruction
- **Search** — find **communities**, **posts**, **users**, or **comments** by keyword (or `All` types at once)
- **Unified output** — posts, comments, communities and users land in one dataset with consistent, flat field names, ready for spreadsheets, databases, or RAG ingestion

### Why use this actor

| Most Lemmy tools | The problem | This actor |
|---|---|---|
| Single-community scrapers | One community per run — instance-wide coverage needs many runs and glue code | Site-wide **feed** + multi-community + comments + search, all in one run |
| Post-only scrapers | No comments, no community/user discovery | Posts **+** comments **+** communities **+** users, unified |
| Roll-your-own API scripts | You maintain cursor-vs-page pagination, view-object flattening, rate-limit retries, and charge logic | One input, one clean flat schema, pay only per result |
| Reddit-only scrapers | Miss the open Fediverse entirely | Native Lemmy / ActivityPub coverage across **any** instance |

**Built to never crash.** Every network call retries transient failures (429 rate-limits, 5xx, timeouts) with exponential backoff and degrades gracefully on hard errors (a missing community is skipped, not fatal) — the run always finishes and delivers whatever it collected. No "under maintenance" dead ends.

### Output fields

**Posts** (`type: "post"`): `id`, `ap_id`, `title`, `body`, `external_url`, `thumbnail_url`, `embed_title`, `embed_description`, `published`, `updated`, `nsfw`, `locked`, `removed`, `deleted`, `featured_community`, `featured_local`, `language_id`, `score`, `upvotes`, `downvotes`, `comments_count`, `newest_comment_time`, `community_id`, `community_name`, `community_title`, `community_actor_id`, `creator_id`, `creator_name`, `creator_display_name`, `creator_actor_id`, `creator_instance_id`

**Comments** (`type: "comment"`): `id`, `ap_id`, `content`, `path`, `published`, `updated`, `distinguished`, `language_id`, `score`, `upvotes`, `downvotes`, `child_count`, `post_id`, `post_title`, `community_id`, `community_name`, `community_actor_id`, `creator_id`, `creator_name`, `creator_display_name`, `creator_actor_id`

**Communities** (`type: "community"`): `id`, `name`, `title`, `actor_id`, `description`, `published`, `nsfw`, `posting_restricted_to_mods`, `instance_id`, `icon`, `banner`, `subscribers`, `posts_count`, `comments_count`, `users_active_day`, `users_active_week`, `users_active_month`, `users_active_half_year`

**Users** (`type: "user"`): `id`, `name`, `display_name`, `actor_id`, `bio`, `published`, `banned`, `bot_account`, `instance_id`, `avatar`, `banner`, `matrix_user_id`, `post_count`, `comment_count`

Every post, comment, community and user carries its `ap_id` / `actor_id` — the canonical ActivityPub URL — so you can join records back to the live Fediverse or across instances.

### Usage examples

Site-wide hot feed:

```json
{ "mode": "feed", "instance": "lemmy.world", "postSort": "Hot", "listingType": "All", "maxResultsPerTerm": 500 }
````

Posts from several communities (local or federated `name@instance`):

```json
{
  "mode": "community",
  "instance": "lemmy.world",
  "communities": ["technology", "selfhosted@lemmy.world", "privacy"],
  "postSort": "TopWeek",
  "maxResultsPerTerm": 300
}
```

Recent comments in a community:

```json
{ "mode": "comments", "communities": ["technology"], "commentSort": "New", "maxResultsPerTerm": 200 }
```

Discover communities and users about a topic:

```json
{ "mode": "search", "searchTerms": ["selfhosted", "homelab"], "searchType": "All" }
```

### Common use cases

- **Social listening / brand monitoring** — track a product, keyword, or community across the Fediverse, outside walled gardens
- **Reddit-alternative monitoring** — follow communities that migrated off Reddit to the open web
- **Community analytics** — rank Lemmy communities by subscribers and active users to find where a topic actually lives
- **RAG & LLM training data** — feed fresh, openly-licensed public discourse into retrieval-augmented and fine-tuning pipelines
- **Academic & network research** — collect public posts, comments, and community/user metadata at scale for NLP or social-graph analysis
- **Sentiment & trend analysis** — measure opinion on trending topics with upvote/downvote/score signals included

### Pricing

**Pay per result** — $0.003 per item (post, comment, community, or user). You are billed only for rows actually delivered to your dataset.

- 1,000 items ≈ **$3**
- 5,000 items ≈ **$15**

No monthly fee, no proxy surcharge, no charge for empty runs.

### Technical notes

- Uses each instance's official Lemmy **REST API v3** (`/post/list`, `/comment/list`, `/search`) — free, public, keyless, no anti-bot bypass required. Verified live against `lemmy.world` (Lemmy 0.19.19).
- **Zero proxy cost** — official public API, no residential proxies needed.
- **Handles both pagination models for you:** `/post/list` uses opaque **cursor** pagination (`next_page` → `page_cursor`), while `/comment/list` and `/search` use classic 1-indexed `page`. You just set `maxResultsPerTerm`.
- **Resilient by design:** transient errors (429/5xx/network) are retried with backoff; hard errors (bad community, unsupported sort) are skipped, not fatal; the run always exits cleanly with partial results rather than failing.
- Polite pacing (~4 requests/sec) stays comfortably inside instance rate limits.
- Automatically stops when your spending limit is reached — results are delivered before they are charged, so no overrun.

#### Honest scope / limits

- **Post ordering** honors Lemmy's server-side `sort`; `Top*` windows are relative to run time (a snapshot, not a live stream).
- **Comments mode** returns comments as a flat list with a `path` field (materialized tree position `0.123.456`) — reconstruct threads client-side from `path` when you need the tree.
- **Search** depth depends on what the chosen instance has federated and indexed; a niche term may return fewer rows on a small instance than on `lemmy.world`. Point the actor at the instance closest to your topic for best coverage.
- Output is a snapshot at run time; **schedule recurring runs** for ongoing monitoring.

### Data compliance

This actor accesses only **public** Lemmy data through each instance's official, publicly documented REST API. No login credentials are used, and no private or authenticated content is touched. Public posts, comments, and communities on Lemmy are intentionally public. Use responsibly, respect each instance's terms of service, and honor the authors of the content you collect.

# Actor input Schema

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

What to scrape. feed = site-wide posts by sort/type; community = posts from named communities; comments = recent comments (site-wide or per community); search = find communities/posts/users/comments by keyword.

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

Instance host to query (Lemmy is federated — no global API). Default lemmy.world (largest). Any Lemmy instance exposes the same /api/v3 REST API.

## `communities` (type: `array`):

Community names to pull posts for, e.g. 'technology' (local) or 'technology@lemmy.world' (federated). Each runs as a separate query.

## `searchTerms` (type: `array`):

Keywords to search. Each term runs as a separate query.

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

How to order posts.

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

All = the whole federated feed the instance sees; Local = only communities hosted on this instance.

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

How to order comments.

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

What to search for.

## `maxResultsPerTerm` (type: `integer`):

Maximum results per community / search term (feed mode is a single query). Higher values increase cost and run time.

## Actor input object example

```json
{
  "mode": "feed",
  "instance": "lemmy.world",
  "communities": [
    "technology"
  ],
  "searchTerms": [
    "selfhosted"
  ],
  "postSort": "Active",
  "listingType": "All",
  "commentSort": "New",
  "searchType": "Communities",
  "maxResultsPerTerm": 200
}
```

# 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 = {
    "instance": "lemmy.world",
    "communities": [
        "technology"
    ],
    "searchTerms": [
        "selfhosted"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("claudethegoat/lemmy-fediverse-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 = {
    "instance": "lemmy.world",
    "communities": ["technology"],
    "searchTerms": ["selfhosted"],
}

# Run the Actor and wait for it to finish
run = client.actor("claudethegoat/lemmy-fediverse-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 '{
  "instance": "lemmy.world",
  "communities": [
    "technology"
  ],
  "searchTerms": [
    "selfhosted"
  ]
}' |
apify call claudethegoat/lemmy-fediverse-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Lemmy Scraper - Posts, Comments, Communities & Search",
        "description": "Scrape Lemmy (any instance) via the official public REST API v3: a site-wide feed by sort/type, posts from named communities, recent comments, and full-text search over communities/posts/users/comments. Federated Reddit-alternative data, no credentials, no proxy required.",
        "version": "0.2",
        "x-build-id": "z46PYgLNk1IY7c3bV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/claudethegoat~lemmy-fediverse-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-claudethegoat-lemmy-fediverse-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/claudethegoat~lemmy-fediverse-scraper/runs": {
            "post": {
                "operationId": "runs-sync-claudethegoat-lemmy-fediverse-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/claudethegoat~lemmy-fediverse-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-claudethegoat-lemmy-fediverse-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": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "feed",
                            "community",
                            "comments",
                            "search"
                        ],
                        "type": "string",
                        "description": "What to scrape. feed = site-wide posts by sort/type; community = posts from named communities; comments = recent comments (site-wide or per community); search = find communities/posts/users/comments by keyword.",
                        "default": "feed"
                    },
                    "instance": {
                        "title": "Lemmy instance",
                        "type": "string",
                        "description": "Instance host to query (Lemmy is federated — no global API). Default lemmy.world (largest). Any Lemmy instance exposes the same /api/v3 REST API.",
                        "default": "lemmy.world"
                    },
                    "communities": {
                        "title": "Communities (community mode)",
                        "type": "array",
                        "description": "Community names to pull posts for, e.g. 'technology' (local) or 'technology@lemmy.world' (federated). Each runs as a separate query.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchTerms": {
                        "title": "Search terms (search mode)",
                        "type": "array",
                        "description": "Keywords to search. Each term runs as a separate query.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "postSort": {
                        "title": "Post sort (feed / community mode)",
                        "enum": [
                            "Active",
                            "Hot",
                            "New",
                            "Old",
                            "TopDay",
                            "TopWeek",
                            "TopMonth",
                            "TopYear",
                            "TopAll",
                            "MostComments",
                            "NewComments"
                        ],
                        "type": "string",
                        "description": "How to order posts.",
                        "default": "Active"
                    },
                    "listingType": {
                        "title": "Listing type (feed / comments mode)",
                        "enum": [
                            "All",
                            "Local"
                        ],
                        "type": "string",
                        "description": "All = the whole federated feed the instance sees; Local = only communities hosted on this instance.",
                        "default": "All"
                    },
                    "commentSort": {
                        "title": "Comment sort (comments mode)",
                        "enum": [
                            "Hot",
                            "Top",
                            "New",
                            "Old",
                            "Controversial"
                        ],
                        "type": "string",
                        "description": "How to order comments.",
                        "default": "New"
                    },
                    "searchType": {
                        "title": "Search type (search mode)",
                        "enum": [
                            "All",
                            "Communities",
                            "Posts",
                            "Users",
                            "Comments",
                            "Url"
                        ],
                        "type": "string",
                        "description": "What to search for.",
                        "default": "Communities"
                    },
                    "maxResultsPerTerm": {
                        "title": "Max results per term",
                        "minimum": 1,
                        "maximum": 20000,
                        "type": "integer",
                        "description": "Maximum results per community / search term (feed mode is a single query). Higher values increase cost and run time.",
                        "default": 200
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```