# BrightTALK Webinar Search Scraper (`automation-lab/brighttalk-webinar-search-scraper`) Actor

Extract public BrightTALK webinar listings with titles, dates, speakers, channels, tags, images, URLs, and status for B2B marketing research.

- **URL**: https://apify.com/automation-lab/brighttalk-webinar-search-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** 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

## BrightTALK Webinar Search Scraper

Extract public BrightTALK webinar search results into clean, structured data for demand generation, competitive intelligence, sponsorship research, and content marketing workflows.

### What does BrightTALK Webinar Search Scraper do?

BrightTALK Webinar Search Scraper searches public BrightTALK webinar listings by keyword and returns one structured dataset item per webinar result.

It captures public webinar metadata such as title, description, dates, channel, speaker names, tags, duration, thumbnail URLs, status, and public engagement counters when BrightTALK returns them.

The actor is designed for repeat monitoring jobs, topic research, and B2B content discovery.

### Who is it for?

Demand generation teams can monitor new webinar topics and competitor campaigns.

Content marketers can discover how vendors package thought leadership and educational events.

Competitive intelligence analysts can track public event calendars by company, product, and market category.

Sponsorship and partnership teams can identify active webinar channels and event themes.

Sales operations teams can enrich account research with public education and event signals.

### Why scrape BrightTALK webinar search results?

BrightTALK contains a large volume of B2B webinar content across technology, security, marketing, finance, data, and enterprise operations.

Manual monitoring is slow when you need recurring searches across many topics.

This actor turns search results into exportable JSON, CSV, Excel, and API-ready datasets.

### What data can you extract?

| Field | Description |
| --- | --- |
| `query` | Search term that produced the result |
| `brighttalkId` | BrightTALK communication ID when available |
| `title` | Webinar title |
| `description` | Public webinar abstract |
| `url` | Public webinar or channel URL returned by BrightTALK |
| `brighttalkUrl` | Derived BrightTALK webcast URL when possible |
| `channelId` | BrightTALK channel ID |
| `channelName` | Channel/provider name when returned |
| `channelLogoUrl` | Provider/channel logo |
| `status` | Upcoming, recorded, or other public status |
| `scheduledAt` | Scheduled date/time |
| `startAt` | Start date/time |
| `timeZone` | Webinar timezone |
| `durationSeconds` | Duration in seconds |
| `durationMinutes` | Duration in minutes |
| `speakers` | Parsed presenter list |
| `tags` | Parsed keyword/tag list |
| `thumbnailUrl` | Thumbnail image |
| `previewImageUrl` | Larger preview image |
| `calendarUrl` | Public calendar file URL |
| `totalViewings` | Public viewing count when returned |
| `registrations` | Public registration count when returned |
| `scrapedAt` | Extraction timestamp |

### How much does it cost to scrape BrightTALK webinars?

The actor uses pay-per-event pricing.

There is a $0.005 start fee per run and formula-derived per-result pricing.

The current BRONZE per-result price is about $0.000031188 per saved webinar, with tier discounts for higher Apify plans.

Use a small `maxItems` value for the first run.

Increase the limit only after you confirm that the query returns useful results.

### How to use it

1. Open the actor on Apify.
2. Enter one or more BrightTALK search queries.
3. Choose the maximum number of webinar records.
4. Optionally choose sorting, duration, and status filters.
5. Start the run.
6. Download results from the dataset as JSON, CSV, Excel, XML, or RSS.

### Example searches

Search for competitor webinar programs.

Search for product categories such as `application security`.

Search for market topics such as `demand generation`.

Search for vendor names to track active event promotion.

Search for compliance topics such as `zero trust` or `data governance`.

### Input options

#### queries

A list of BrightTALK search keywords.

Each query is sent to BrightTALK's public webinar search endpoint.

#### maxItems

The maximum number of webinar records saved across all queries.

The default is 20.

#### sort

Choose relevance, newest/date, or most viewed.

#### duration

Choose any duration, under 5 minutes, under 20 minutes, or over 20 minutes.

#### status

Choose all public records, upcoming only, or recorded/on-demand only.

#### deduplicate

When enabled, repeated webinar IDs are saved only once across multiple queries.

Disable it if you need query-by-query match attribution.

### Output example

```json
{
  "query": "cybersecurity",
  "brighttalkId": 669977,
  "title": "Is your AppSec program Mythos Ready?",
  "url": "https://www.blackduck.com/resources/webinars.html?commid=669977",
  "channelId": 13983,
  "status": "upcoming",
  "scheduledAt": "2026-06-25T09:00:00Z",
  "durationMinutes": 32.6,
  "speakers": ["Patrick Carey"],
  "tags": ["AI", "Application Security"],
  "scrapedAt": "2026-06-23T02:00:00.000Z"
}
````

### Tips for better results

Use specific B2B terms instead of very broad one-word searches.

Combine competitor names with product categories.

Run recurring tasks weekly for monitoring workflows.

Use `sort=date` to find recently added or scheduled webinars.

Use `status=upcoming` for event calendar tracking.

Use `status=recorded` for content library research.

### Integrations

Send the dataset to Google Sheets for campaign monitoring.

Export CSV files for analyst review.

Use the Apify API to sync records into a CRM or marketing operations database.

Trigger webhooks when new webinars match strategic topics.

Combine results with enrichment actors for account research.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/brighttalk-webinar-search-scraper').call({
  queries: ['cybersecurity', 'zero trust'],
  maxItems: 100,
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/brighttalk-webinar-search-scraper').call(run_input={
    'queries': ['demand generation'],
    'maxItems': 100,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~brighttalk-webinar-search-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"queries":["application security"],"maxItems":100}'
```

### MCP usage

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

MCP URL:

`https://mcp.apify.com/?tools=automation-lab/brighttalk-webinar-search-scraper`

Claude Code setup:

```bash
claude mcp add apify-brighttalk-webinars https://mcp.apify.com/?tools=automation-lab/brighttalk-webinar-search-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-brighttalk-webinars": {
      "url": "https://mcp.apify.com/?tools=automation-lab/brighttalk-webinar-search-scraper"
    }
  }
}
```

Example prompts:

- "Search BrightTALK for upcoming webinars about application security and summarize the channels."
- "Find public BrightTALK webinars mentioning demand generation and export the data as a table."
- "Monitor BrightTALK for zero trust webinar topics and show me new records."

### BrightTALK search behavior

The actor uses public BrightTALK search results.

It does not log in.

It does not register for webinars.

It does not access gated playback or private attendee data.

### Limitations

Channel names may be missing when BrightTALK returns only channel IDs and logos.

Some URLs point to vendor-hosted webinar landing pages rather than BrightTALK pages.

Status labels depend on BrightTALK's public API response.

Very broad queries can return thousands of matches, so use `maxItems` to control spend.

### Legality

This actor collects public metadata from BrightTALK search results.

### Legal and ethical use

This actor collects public metadata from BrightTALK search results.

Use the data responsibly.

Respect BrightTALK's terms, privacy rules, and applicable laws.

Do not use extracted metadata for spam or abusive outreach.

### FAQ

#### Does this actor collect webinar attendee lists?

No. It collects only public webinar listing metadata.

#### Does it require a BrightTALK account?

No. The actor uses public search results.

#### Why is `channelName` sometimes empty?

BrightTALK search results sometimes return channel IDs and logos without a channel title.

#### Why do some URLs point outside BrightTALK?

BrightTALK may return vendor-hosted webinar URLs for certain channels.

#### How do I reduce duplicate results?

Keep `deduplicate` enabled.

#### How do I monitor new webinars?

Create an Apify task with `sort=date`, your topic queries, and a schedule.

### Troubleshooting

If a run returns no records, try a broader query or remove status and duration filters.

If results look duplicated, keep deduplication enabled and use fewer overlapping queries.

If records are missing channel names, use `channelId` and `channelLogoUrl` as stable provider signals.

### Related scrapers

Explore more automation-lab actors for marketing research, lead generation, and content monitoring on Apify.

Useful companion workflows include website contact discovery, company enrichment, social media monitoring, and generic website crawling.

### Changelog

Initial version extracts public BrightTALK webinar search metadata from the public search API.

### Support

If you need a field that is visible publicly on BrightTALK but not included yet, open an issue with an example URL and expected output field.

# Actor input Schema

## `queries` (type: `array`):

Keywords to search on BrightTALK, such as topics, competitors, vendors, technologies, or webinar themes.

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

Maximum number of webinar records to save across all queries. Keep this low for first tests, then increase for monitoring jobs.

## `sort` (type: `string`):

How BrightTALK should rank webinar search results.

## `duration` (type: `string`):

Optional BrightTALK duration filter.

## `status` (type: `string`):

Filter output records after BrightTALK returns results.

## `deduplicate` (type: `boolean`):

Remove duplicate webinar IDs across multiple queries. Disable if you want to know which query matched each webinar.

## Actor input object example

```json
{
  "queries": [
    "cybersecurity",
    "demand generation"
  ],
  "maxItems": 20,
  "sort": "relevance",
  "duration": "any",
  "status": "any",
  "deduplicate": true
}
```

# 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 = {
    "queries": [
        "cybersecurity",
        "demand generation"
    ],
    "maxItems": 20,
    "sort": "relevance",
    "duration": "any",
    "status": "any",
    "deduplicate": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/brighttalk-webinar-search-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 = {
    "queries": [
        "cybersecurity",
        "demand generation",
    ],
    "maxItems": 20,
    "sort": "relevance",
    "duration": "any",
    "status": "any",
    "deduplicate": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/brighttalk-webinar-search-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 '{
  "queries": [
    "cybersecurity",
    "demand generation"
  ],
  "maxItems": 20,
  "sort": "relevance",
  "duration": "any",
  "status": "any",
  "deduplicate": true
}' |
apify call automation-lab/brighttalk-webinar-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "BrightTALK Webinar Search Scraper",
        "description": "Extract public BrightTALK webinar listings with titles, dates, speakers, channels, tags, images, URLs, and status for B2B marketing research.",
        "version": "0.1",
        "x-build-id": "5bR9WUtRpX3WKWMGI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~brighttalk-webinar-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-brighttalk-webinar-search-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~brighttalk-webinar-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-brighttalk-webinar-search-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~brighttalk-webinar-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-brighttalk-webinar-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "BrightTALK search queries",
                        "minItems": 1,
                        "type": "array",
                        "description": "Keywords to search on BrightTALK, such as topics, competitors, vendors, technologies, or webinar themes.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum webinars",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of webinar records to save across all queries. Keep this low for first tests, then increase for monitoring jobs.",
                        "default": 20
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "relevance",
                            "date",
                            "views"
                        ],
                        "type": "string",
                        "description": "How BrightTALK should rank webinar search results.",
                        "default": "relevance"
                    },
                    "duration": {
                        "title": "Webinar duration",
                        "enum": [
                            "any",
                            "under_5_minutes",
                            "under_20_minutes",
                            "over_20_minutes"
                        ],
                        "type": "string",
                        "description": "Optional BrightTALK duration filter.",
                        "default": "any"
                    },
                    "status": {
                        "title": "Webinar status",
                        "enum": [
                            "any",
                            "upcoming",
                            "recorded"
                        ],
                        "type": "string",
                        "description": "Filter output records after BrightTALK returns results.",
                        "default": "any"
                    },
                    "deduplicate": {
                        "title": "Deduplicate webinars",
                        "type": "boolean",
                        "description": "Remove duplicate webinar IDs across multiple queries. Disable if you want to know which query matched each webinar.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
