# Event Buzz Radar: Material 8-K Plus Reddit and HN Chatter (`scrapemint/event-buzz-radar-pipeline`) Actor

For each ticker, pairs material 8-K events with Reddit and Hacker News chatter on the same company, scores 0 to 100, and tiers each event hot, elevated, or watch. A material filing the crowd is reacting to is the signal. Pure public data, no API keys.

- **URL**: https://apify.com/scrapemint/event-buzz-radar-pipeline.md
- **Developed by:** [Ken M](https://apify.com/scrapemint) (community)
- **Categories:** Business, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

## Event Buzz Radar: Material 8-K Plus Reddit and HN Chatter

For each ticker, this pipeline finds the **material 8-K events** and checks whether **the crowd is talking about that company** on Reddit and Hacker News right now. A material corporate event is a catalyst. The same event with retail attention building around it is a *tradable* catalyst. The edge is the **overlap** between a real news event and rising crowd attention.

Every data source is plain HTTP or a public JSON API (**SEC EDGAR**, **Reddit RSS**, **HN Algolia**), with no browser, no proxy, and no API keys, so runs are fast and cheap.

### What it does

1. **Material 8-K events.** Pulls recent 8-K filings for your tickers and reads the item codes. Routine filings (exhibits, routine votes) are dropped by default; the ones that move stocks are kept.
2. **Social chatter.** Searches Reddit and Hacker News for each company by cashtag (`$TICKER`) and, when you supply it, by company name. A keyword filter keeps matches precise so generic-word tickers do not pull noise.
3. **Reaction, not volume.** For each filing, the chatter is split into a post-filing **reaction window** (default 7 days after the filing) and the **pre-filing baseline**. Buzz is scored on the reaction *spiking* above baseline, so a company that is always talked about does not register as reacting. The overlap of a material event and a real chatter spike is scored 0 to 100 and tiered.

### Scoring

The radar score (0 to 100) is the sum of:

- **Materiality (up to 45).** High-material items (a material agreement, a completed acquisition, a change in control, a restatement) score above medium items (earnings, an executive change, a new obligation), which score above routine.
- **Buzz (up to 40).** Post-filing Reddit plus Hacker News mentions, weighted by Hacker News points and comments, with a bonus for how sharply chatter spiked above the company's pre-filing baseline.
- **Recency (up to 15).** A filing the crowd is reacting to today scores above a stale one.

A material event only reaches **hot** when post-filing chatter both clears the minimum mention count and runs at least 1.5x the company's baseline rate. A perpetually-discussed mega-cap with steady chatter sits near 1.0x and stays out of the hot tier.

Tiers:

- **hot** — a material event with social chatter above the threshold at the same time. The premium signal.
- **elevated** — any event with real chatter, or a high-materiality event with lighter chatter.
- **watch** — a material event with little or no chatter.

### Output

One row per material 8-K event:

```json
{
  "ticker": "GME",
  "company": "GameStop Corp",
  "eventType": "8-K",
  "items": [{ "code": "1.01", "description": "Entry into a material agreement" }],
  "topItem": { "code": "1.01", "description": "Entry into a material agreement" },
  "materiality": "high",
  "reportDate": "2026-06-05",
  "filingUrl": "https://www.sec.gov/Archives/edgar/data/.../",
  "daysAgo": 2,
  "radarScore": 81,
  "tier": "hot",
  "scoreBreakdown": { "materiality": 45, "buzz": 21, "recency": 15 },
  "buzz": {
    "reactionWindowDays": 7,
    "reactionMentions": 9,
    "baselineMentions": 2,
    "spikeRatio": 4.5,
    "redditCount": 6,
    "hnCount": 3,
    "hnPoints": 64,
    "hnComments": 22,
    "lastBuzzDate": "2026-06-07",
    "topPosts": [{ "source": "reddit", "title": "GME just filed an 8-K", "url": "https://reddit.com/...", "points": null, "date": "2026-06-07" }]
  },
  "scoredAt": "2026-06-07T10:00:00.000Z"
}
````

### Input

- `tickers` (or `ciks`) — the companies to scan (the `$TICKER` cashtag drives social search).
- `companyNames` — optional map of ticker to company name, e.g. `{"GME": "GameStop"}`, to catch posts that never use the cashtag.
- `maxAgeHours` — how far back to read 8-K filings (default 168 = 7 days).
- `buzzMaxAgeHours` — how far back to pull chatter, covering reaction plus baseline (default 336 = 14 days).
- `reactionWindowDays` — days after a filing in which chatter counts as a reaction to it (default 7).
- `minMentions` — post-filing posts needed (alongside a spike above baseline) to count as a reaction (default 2).
- `materialOnly`, `includeBuzz`, `maxPostsPerSource`, `maxEventsTotal`, `minScore` — toggles and caps.

### Pricing and combined cost

This actor charges per scored event: **watch $0.04**, **elevated $0.09**, **hot $0.14**. The first hot event per run is free so you can validate output.

This is a pipeline: it runs three child actors, and **each child also bills you for its own per-item usage** (sec-8k-event-tracker per filing, reddit-lead-monitor per post, hn-lead-monitor per item). Your total for a run is the tier charges above **plus** those child charges. Because all three children are plain HTTP / public-API calls, the per-run compute is small.

### Notes

- Reddit posts pulled via RSS carry no vote or comment counts, so Reddit contributes mention count only; Hacker News supplies the engagement weight.
- A material event with no chatter is still useful, so it is kept as a watch row rather than dropped.
- Supplying `companyNames` materially improves buzz coverage for tickers people rarely write as a cashtag.

# Actor input Schema

## `tickers` (type: `array`):

Stock tickers to scan, e.g. \["GME", "NVDA", "PLTR"]. The buzz search uses the cashtag form ($TICKER) to keep social matches precise. Provide tickers or CIKs.

## `ciks` (type: `array`):

SEC CIK numbers, an alternative to tickers. Buzz is matched once the 8-K resolves the CIK to a ticker.

## `companyNames` (type: `object`):

Map of ticker to company name, e.g. {"GME": "GameStop"}. Adds a second social search by name so you also catch posts that never use the cashtag.

## `maxAgeHours` (type: `integer`):

Ignore 8-K filings older than this. 168 = 7 days. Recent filings are where a chatter reaction is still measurable.

## `buzzMaxAgeHours` (type: `integer`):

How far back to pull Reddit and Hacker News posts. 336 = 14 days. Must comfortably exceed the event window plus the reaction window so there is both a post-filing reaction and a pre-filing baseline to compare.

## `reactionWindowDays` (type: `integer`):

Only chatter posted within this many days AFTER a filing counts as a reaction to it. Posts before the filing form the baseline the reaction is measured against. Keeps buzz tied to the event instead of a company's steady background chatter.

## `minMentions` (type: `integer`):

A filing needs at least this many post-filing Reddit plus Hacker News posts (and a chatter spike above the company's baseline) to count as a reaction. Below it, buzz is treated as absent.

## `materialOnly` (type: `boolean`):

Drop 8-K filings that carry only routine items (such as exhibits or routine votes) and keep the ones that move stocks.

## `includeBuzz` (type: `boolean`):

Pull Reddit and Hacker News chatter. Turn off to score on event materiality alone.

## `maxPostsPerSource` (type: `integer`):

Per query cap passed to the Reddit and Hacker News children. Controls cost.

## `maxEventsTotal` (type: `integer`):

Cap on events scored, most recent first.

## `minScore` (type: `integer`):

Drop and never charge events scoring below this 0 to 100 threshold. 0 keeps every material event.

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

Optional. EDGAR, Reddit RSS, and the HN Algolia API do not need a proxy, so the default is no proxy.

## Actor input object example

```json
{
  "tickers": [
    "GME",
    "PLTR",
    "SOFI"
  ],
  "ciks": [],
  "companyNames": {},
  "maxAgeHours": 168,
  "buzzMaxAgeHours": 336,
  "reactionWindowDays": 7,
  "minMentions": 2,
  "materialOnly": true,
  "includeBuzz": true,
  "maxPostsPerSource": 80,
  "maxEventsTotal": 100,
  "minScore": 0,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "tickers": [
        "GME",
        "PLTR",
        "SOFI"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapemint/event-buzz-radar-pipeline").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 = { "tickers": [
        "GME",
        "PLTR",
        "SOFI",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("scrapemint/event-buzz-radar-pipeline").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 '{
  "tickers": [
    "GME",
    "PLTR",
    "SOFI"
  ]
}' |
apify call scrapemint/event-buzz-radar-pipeline --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapemint/event-buzz-radar-pipeline",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Event Buzz Radar: Material 8-K Plus Reddit and HN Chatter",
        "description": "For each ticker, pairs material 8-K events with Reddit and Hacker News chatter on the same company, scores 0 to 100, and tiers each event hot, elevated, or watch. A material filing the crowd is reacting to is the signal. Pure public data, no API keys.",
        "version": "0.1",
        "x-build-id": "CGhA5SegMPVT3c7xS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapemint~event-buzz-radar-pipeline/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapemint-event-buzz-radar-pipeline",
                "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/scrapemint~event-buzz-radar-pipeline/runs": {
            "post": {
                "operationId": "runs-sync-scrapemint-event-buzz-radar-pipeline",
                "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/scrapemint~event-buzz-radar-pipeline/run-sync": {
            "post": {
                "operationId": "run-sync-scrapemint-event-buzz-radar-pipeline",
                "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": {
                    "tickers": {
                        "title": "Tickers",
                        "type": "array",
                        "description": "Stock tickers to scan, e.g. [\"GME\", \"NVDA\", \"PLTR\"]. The buzz search uses the cashtag form ($TICKER) to keep social matches precise. Provide tickers or CIKs.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "ciks": {
                        "title": "CIKs (optional)",
                        "type": "array",
                        "description": "SEC CIK numbers, an alternative to tickers. Buzz is matched once the 8-K resolves the CIK to a ticker.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "companyNames": {
                        "title": "Company names (optional)",
                        "type": "object",
                        "description": "Map of ticker to company name, e.g. {\"GME\": \"GameStop\"}. Adds a second social search by name so you also catch posts that never use the cashtag.",
                        "default": {}
                    },
                    "maxAgeHours": {
                        "title": "Event max age (hours)",
                        "minimum": 24,
                        "maximum": 8760,
                        "type": "integer",
                        "description": "Ignore 8-K filings older than this. 168 = 7 days. Recent filings are where a chatter reaction is still measurable.",
                        "default": 168
                    },
                    "buzzMaxAgeHours": {
                        "title": "Chatter fetch window (hours)",
                        "minimum": 24,
                        "maximum": 4320,
                        "type": "integer",
                        "description": "How far back to pull Reddit and Hacker News posts. 336 = 14 days. Must comfortably exceed the event window plus the reaction window so there is both a post-filing reaction and a pre-filing baseline to compare.",
                        "default": 336
                    },
                    "reactionWindowDays": {
                        "title": "Reaction window (days)",
                        "minimum": 1,
                        "maximum": 60,
                        "type": "integer",
                        "description": "Only chatter posted within this many days AFTER a filing counts as a reaction to it. Posts before the filing form the baseline the reaction is measured against. Keeps buzz tied to the event instead of a company's steady background chatter.",
                        "default": 7
                    },
                    "minMentions": {
                        "title": "Minimum reaction mentions",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "A filing needs at least this many post-filing Reddit plus Hacker News posts (and a chatter spike above the company's baseline) to count as a reaction. Below it, buzz is treated as absent.",
                        "default": 2
                    },
                    "materialOnly": {
                        "title": "Material events only",
                        "type": "boolean",
                        "description": "Drop 8-K filings that carry only routine items (such as exhibits or routine votes) and keep the ones that move stocks.",
                        "default": true
                    },
                    "includeBuzz": {
                        "title": "Include social buzz",
                        "type": "boolean",
                        "description": "Pull Reddit and Hacker News chatter. Turn off to score on event materiality alone.",
                        "default": true
                    },
                    "maxPostsPerSource": {
                        "title": "Max posts per social search",
                        "minimum": 10,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Per query cap passed to the Reddit and Hacker News children. Controls cost.",
                        "default": 80
                    },
                    "maxEventsTotal": {
                        "title": "Max events to score",
                        "minimum": 1,
                        "maximum": 400,
                        "type": "integer",
                        "description": "Cap on events scored, most recent first.",
                        "default": 100
                    },
                    "minScore": {
                        "title": "Minimum radar score",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Drop and never charge events scoring below this 0 to 100 threshold. 0 keeps every material event.",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. EDGAR, Reddit RSS, and the HN Algolia API do not need a proxy, so the default is no proxy.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```