# KDP book niche analyzer (`getascraper/kdp-book-niche-analyzer`) Actor

Research Kindle Store book niches by keyword. Get Best Sellers Rank, format, page count, category, price, and rating for every book, plus a niche-level competition summary self-publishers can act on.

- **URL**: https://apify.com/getascraper/kdp-book-niche-analyzer.md
- **Developed by:** [GetAScraper](https://apify.com/getascraper) (community)
- **Categories:** E-commerce, SEO tools, Developer tools
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.66 / 1,000 book records

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## 📚 KDP book niche analyzer

**Find out if a self-publishing niche is worth writing for, before you write a single page.**

KDP book niche analyzer searches the Kindle Store for any keyword or genre, such as "gratitude journal", "nurse planner", or "dog mom notebook". It pulls Best Sellers Rank, category rank, price, rating, review count, page count, and publish date for every matching book, then rolls the whole niche up into one plain-English competition score.

### 🔍 What does KDP book niche analyzer do?

Type in a keyword and this actor searches the Kindle Store on your behalf. For every book it finds, it visits that book's own page and reads its real sales signals: Best Sellers Rank, every category it ranks in, price, star rating, review count, page count, publisher, and publish date.

Most niche research tools stop at review count and star rating. Those numbers tell you how a book was received, not whether it is actually selling. Best Sellers Rank is the number Amazon itself uses to signal real sales volume, and this actor is one of the very few tools that pulls it for you automatically, at scale, across an entire keyword.

### 💡 Why use KDP book niche analyzer?

- **I am a low content book publisher** scouting my next journal or planner idea, and I want to know how many other books already dominate that keyword before I invest a week designing one.
- **I am a fiction or nonfiction self-publisher** checking whether a genre keyword is crowded with established, high-selling titles or still has room for a new release.
- **I am a KDP coach or course creator** who needs fresh, real examples of saturated versus open niches to show students, instead of screenshots that go stale in a month.
- **I am a book marketing agency** running niche viability checks for multiple author clients before recommending which title idea to greenlight.

### 🚀 How to use KDP book niche analyzer

1. Open the actor and type in a niche keyword, like "gratitude journal" or "productivity planner".
2. Set how many books you want analyzed, or leave the default for a quick first look.
3. Click **Start** and let the actor search the Kindle Store and read each book's own page.
4. Open the **Dataset** tab for every book's full data, and check the **Key-value store** tab for the one-line niche summary and competition score.

### 📥 Input

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| Niche keyword | string | Yes | A Kindle Store keyword or genre to research, for example "gratitude journal", "nurse planner", or "dog mom notebook". |
| Max books | integer | No | Maximum number of book records to return. Use 0 for no limit. |
| Fetch book detail pages | boolean | No | When enabled (default), visits each book's own page for Best Sellers Rank, category, format, page count, and publish date. Disable for a faster, lighter run when you only need a raw list of matching titles. |
| Include niche summary | boolean | No | When enabled (default), adds one extra summary record with the median Best Sellers Rank, price band, review spread, and a documented competition score for the whole niche. |
| Proxy configuration | object | No | Leave on the default setting. It is already targeted to return US pricing. |

### 📤 Output

Each dataset row is one book, with its real sales and listing signals.

```json
{
    "asin": "B0GBVMTCQK",
    "title": "90 Day 5-Min Gratitude Journal (Kindle Scribe Only): A Guided Daily Practice for Happiness, Abundance, Affirmation & Reflection, Undated Daily Journal for Women & Men",
    "author": "Luna Grove",
    "format": "Kindle Edition",
    "price": 3.99,
    "currency": "$",
    "rating": 5,
    "reviewCount": 1,
    "bsrOverall": 402322,
    "bsrOverallCategory": "Kindle Store",
    "bsrCategoryRank": 13,
    "bsrCategoryName": "Guided Journals (Kindle Store)",
    "categoryRanks": [
        "#13 in Guided Journals (Kindle Store)",
        "#64 in Journal Writing",
        "#155 in Journaling"
    ],
    "pageCount": 107,
    "publishDate": "December 29, 2025",
    "detailUrl": "https://www.amazon.com/dp/B0GBVMTCQK",
    "keyword": "gratitude journal",
    "scrapedAt": "2026-07-04T20:06:51.483Z"
}
````

Every run also writes one extra niche summary record to the key-value store, so you get a single, plain-English verdict on top of the raw book list:

```json
{
    "keyword": "gratitude journal",
    "booksAnalyzed": 5,
    "booksWithBsr": 5,
    "medianBsrOverall": 604314,
    "medianPrice": 0.99,
    "medianReviewCount": 10,
    "medianRating": 4.75,
    "priceMin": 0.99,
    "priceMax": 14.16,
    "opportunityScore": 40,
    "opportunityLabel": "Medium competition"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

#### 📊 Data table

| Field | Type | Description |
| --- | --- | --- |
| asin | string | The book's unique Amazon identifier. |
| title | string | The book's title, exactly as listed. |
| author | string | The author or brand name on the listing. |
| format | string | The edition analyzed, always Kindle Edition. |
| price | number | The book's current listed price. |
| currency | string | The currency symbol the price was shown in. |
| rating | number | Average star rating, when the book has any ratings yet. |
| reviewCount | number | Total number of customer reviews. |
| bsrOverall | number | Best Sellers Rank in the overall Kindle Store. Lower means more sales. |
| bsrOverallCategory | string | The store the overall rank was measured against. |
| bsrCategoryRank | number | The book's rank in its top listed category. |
| bsrCategoryName | string | The name of that top category. |
| categoryRanks | array of strings | Every category rank the book holds, not just the top one. |
| pageCount | number | Print length in pages, useful for sizing low content books. |
| publisher | string | The publishing name on record, when shown. |
| publishDate | string | When the book was published. |
| detailUrl | string | Direct link back to the book's own page. |
| keyword | string | The niche keyword this book was found under. |
| scrapedAt | string | The date and time the record was collected. |

Every field is only included when Amazon actually published it. This actor never fills in placeholder text for missing information, so your dataset stays genuine and trustworthy.

### 💰 Pricing

KDP book niche analyzer is pay per result. You only pay for books actually returned, and a run that finds nothing costs nothing. There are no subscriptions or monthly minimums. Check the Pricing tab on this actor's page for the current rate.

### 🧭 Tips for best results

- Try a specific, long-tail keyword first, like "nurse graduation journal" instead of just "journal". Niche keywords give you a truer read on real competition.
- Watch the niche summary's competition score alongside the price band. A niche with a low score but a wide price range often still has room for the right positioning.
- Some books are brand new and have not earned a rating or review yet. That is normal, not a missing-data problem, and it is itself a useful signal about how fresh a niche's competition is.

### ❓ FAQ

**How is the competition score calculated?**
It is built from the actual median Best Sellers Rank and median review count of the books this actor found, with the exact formula included in every niche summary record. Nothing about it is hidden or guessed.

**Why does this actor use Best Sellers Rank instead of just review count?**
Review count tells you how many people left feedback. Best Sellers Rank is the signal Amazon itself uses to reflect real, recent sales volume, which is what actually matters when deciding if a niche is worth entering.

**Does this actor work for physical books too, or only Kindle?**
It searches and analyzes Kindle Store editions specifically, since that is where most self-publishers launch first and where niche research matters most.

**Will I always get a price and rating for every book?**
No, and that is expected. Brand new listings sometimes have no reviews yet, and some books do not display a price the same way. This actor only reports what Amazon has actually published for that title.

**I found a bug or a keyword that returns strange results. What should I do?**
Open an issue on this actor's Issues tab with the keyword you used and a description of what went wrong. If you need a custom research tool built around your own workflow, reach out and we're happy to help.

# Actor input Schema

## `keyword` (type: `string`):

A Kindle Store keyword or genre to research, for example "gratitude journal", "nurse planner", or "dog mom notebook". This Actor searches the Kindle Store for this keyword and analyzes every matching book.

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

Maximum number of book records to push to the dataset. Use 0 for no limit (returns every matching result on the first two Kindle Store search result pages). You are billed per book returned.

## `fetchDetails` (type: `boolean`):

When enabled (default), visits each book's own product page to add Best Sellers Rank, category, format (Kindle/Paperback/Hardcover), page count and publish date on top of the title, price, rating and review count already available from the search results. This is where the actual niche-research value comes from. Disable only for a faster, lighter run when you just need a raw list of matching titles.

## `includeNicheSummary` (type: `boolean`):

When enabled (default), adds one extra summary record to a separate 'Niche summary' dataset with the median Best Sellers Rank, price band, review-count spread and format mix across all books analyzed in this run, plus a documented, BSR-anchored opportunity score. Requires 'Fetch book detail pages' to be enabled for the Best Sellers Rank component of the score; without it, the summary falls back to price and review-count signals only.

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

Amazon serves this data anonymously with no login required. Datacenter proxy targeted to the US is enabled by default so prices are returned in USD rather than a geolocated currency. Amazon also intermittently shows an automated-traffic checkpoint on a small fraction of requests even at low volume; this Actor already retries automatically when that happens, but if you see repeated failures, try enabling a residential proxy group instead.

## Actor input object example

```json
{
  "keyword": "gratitude journal",
  "maxItems": 20,
  "fetchDetails": true,
  "includeNicheSummary": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `books` (type: `string`):

No description

## `nicheSummary` (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 = {
    "keyword": "gratitude journal",
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("getascraper/kdp-book-niche-analyzer").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 = {
    "keyword": "gratitude journal",
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("getascraper/kdp-book-niche-analyzer").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 '{
  "keyword": "gratitude journal",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyCountry": "US"
  }
}' |
apify call getascraper/kdp-book-niche-analyzer --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=getascraper/kdp-book-niche-analyzer",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "KDP book niche analyzer",
        "description": "Research Kindle Store book niches by keyword. Get Best Sellers Rank, format, page count, category, price, and rating for every book, plus a niche-level competition summary self-publishers can act on.",
        "version": "0.1",
        "x-build-id": "InuKKmmqcdBN8etRc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/getascraper~kdp-book-niche-analyzer/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-getascraper-kdp-book-niche-analyzer",
                "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/getascraper~kdp-book-niche-analyzer/runs": {
            "post": {
                "operationId": "runs-sync-getascraper-kdp-book-niche-analyzer",
                "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/getascraper~kdp-book-niche-analyzer/run-sync": {
            "post": {
                "operationId": "run-sync-getascraper-kdp-book-niche-analyzer",
                "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": [
                    "keyword"
                ],
                "properties": {
                    "keyword": {
                        "title": "Niche keyword",
                        "type": "string",
                        "description": "A Kindle Store keyword or genre to research, for example \"gratitude journal\", \"nurse planner\", or \"dog mom notebook\". This Actor searches the Kindle Store for this keyword and analyzes every matching book.",
                        "default": "gratitude journal"
                    },
                    "maxItems": {
                        "title": "Max books",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of book records to push to the dataset. Use 0 for no limit (returns every matching result on the first two Kindle Store search result pages). You are billed per book returned.",
                        "default": 20
                    },
                    "fetchDetails": {
                        "title": "Fetch book detail pages",
                        "type": "boolean",
                        "description": "When enabled (default), visits each book's own product page to add Best Sellers Rank, category, format (Kindle/Paperback/Hardcover), page count and publish date on top of the title, price, rating and review count already available from the search results. This is where the actual niche-research value comes from. Disable only for a faster, lighter run when you just need a raw list of matching titles.",
                        "default": true
                    },
                    "includeNicheSummary": {
                        "title": "Include niche summary",
                        "type": "boolean",
                        "description": "When enabled (default), adds one extra summary record to a separate 'Niche summary' dataset with the median Best Sellers Rank, price band, review-count spread and format mix across all books analyzed in this run, plus a documented, BSR-anchored opportunity score. Requires 'Fetch book detail pages' to be enabled for the Best Sellers Rank component of the score; without it, the summary falls back to price and review-count signals only.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Amazon serves this data anonymously with no login required. Datacenter proxy targeted to the US is enabled by default so prices are returned in USD rather than a geolocated currency. Amazon also intermittently shows an automated-traffic checkpoint on a small fraction of requests even at low volume; this Actor already retries automatically when that happens, but if you see repeated failures, try enabling a residential proxy group instead.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
