# Flipkart Listings Scraper (`khadinakbar/flipkart-listings-scraper`) Actor

Extract public Flipkart search and category listings: product titles, prices, MRP, discounts, ratings, images, availability, and source URLs. Batch queries or listing URLs in, structured listing cards out.

- **URL**: https://apify.com/khadinakbar/flipkart-listings-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** E-commerce, Automation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.00 / 1,000 listing scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Flipkart Listings Scraper

Extract public **Flipkart search and category listing cards** into structured JSON. Send batch keywords or public Flipkart browse URLs and receive product titles, product IDs, prices, MRP, discounts, ratings, rating/review counts, thumbnail URLs, source page, and position.

This is a fast, listing-grade actor for catalog monitoring and market research. It deliberately does **not** visit each product detail page. Use the separate **Flipkart Product Scraper** when you need detail-page specifications, sellers, offers, or descriptions.

### Use it for

- Price and MRP monitoring by keyword or category.
- Assortment, ranking, and rating analysis for ecommerce teams.
- Structured inputs for agents that need public Flipkart listing cards.
- Repeatable exports to JSON, CSV, Excel, XML, RSS, or the Apify API.

It collects public pages only. It does not log in, place orders, or access private customer data.

### Input

| Field | Default | Purpose |
| --- | ---: | --- |
| `searchQueries` | `['wireless earbuds']` | One or more product keywords. |
| `listingUrls` | `[]` | Public Flipkart search, category, browse, or collection URLs. |
| `maxItemsPerInput` | `50` | Result cap for each query or URL. |
| `maxTotalItems` | `500` | Hard cap across the whole run. |
| `maxPagesPerInput` | `10` | Pagination safety cap per input. |
| `sortBy` | `relevance` | Generated-query ordering only. |
| `minPrice`, `maxPrice` | — | INR filters applied after extraction. |
| `minRating` | — | Keeps cards at or above this visible rating. |

#### Example

```json
{
  "searchQueries": ["wireless earbuds", "gaming mouse"],
  "listingUrls": ["https://www.flipkart.com/mobiles/pr?sid=tyy,4io"],
  "maxItemsPerInput": 50,
  "maxTotalItems": 120,
  "sortBy": "price_asc",
  "minRating": 4,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "IN"
  }
}
````

### Output

Each dataset item represents one validated product card:

```json
{
  "productId": "itm6ac6485515ae4",
  "title": "Example Wireless Earbuds",
  "productUrl": "https://www.flipkart.com/example/p/itm6ac6485515ae4",
  "sourceUrl": "https://www.flipkart.com/search?q=wireless+earbuds",
  "sourceType": "search",
  "sourceQuery": "wireless earbuds",
  "position": 1,
  "page": 1,
  "currentPrice": 1499,
  "originalPrice": 2999,
  "discountPercent": 50,
  "rating": 4.2,
  "currency": "INR",
  "scrapedAt": "2026-07-15T12:00:00.000Z"
}
```

Fields unavailable on a particular public card are omitted, not invented. `OUTPUT` contains the compact terminal outcome; `RUN_SUMMARY` contains safe diagnostics, source counts, pagination counts, and charged-event counts.

### Pricing

| Event | Price |
| --- | ---: |
| Actor start | $0.00005 per run |
| Validated listing persisted | $0.006 per listing |

The actor bills a listing only when its complete validated record is stored in the dataset. Filters, duplicates, invalid cards, blocks, and failed pages are not billed. Apify platform usage (including proxy/network) is passed through separately, so use `maxTotalItems` to make the listing-event part of the cost predictable.

### Reliability and limitations

Flipkart is geo-targeted and may challenge datacenter traffic. The actor defaults to Apify Residential Proxy with country `IN`, maintains browser-like sessions, retries transient page failures, and returns an explicit `UPSTREAM_FAILED` outcome when every page is blocked rather than silently returning an empty dataset.

An empty result for a successfully processed query is `VALID_EMPTY`; useful data plus page/write failures is `PARTIAL`. This actor does not guarantee that every field is displayed by every Flipkart listing layout.

### Legal

Use only for lawful collection and processing of public information, consistent with Flipkart's terms, Apify's terms, and applicable laws. This actor is not affiliated with or endorsed by Flipkart.

# Actor input Schema

## `searchQueries` (type: `array`):

Use this when you want to discover products by keyword. Each query is run on Flipkart search, such as 'wireless earbuds' or 'gaming laptop'. You may combine this with listing URLs. The actor returns listing cards only; it does not open every product page for full specifications.

## `listingUrls` (type: `array`):

Use this when you already have a public Flipkart search, category, browse, or collection URL. Each URL is paginated independently. Do not enter product detail URLs containing '/p/'; use the separate Flipkart Product Scraper for product-page details.

## `maxItemsPerInput` (type: `integer`):

Use this when you need a predictable per-query or per-URL budget. The actor stops after this many validated listings for each input. Set a lower value for quick checks and a higher value for catalog exports. Each persisted listing is billed once.

## `maxTotalItems` (type: `integer`):

Use this when several inputs share one run budget. This hard cap applies across all queries and listing URLs, even when their combined per-input limits would be larger. It prevents accidental over-collection and caps per-listing event charges.

## `maxPagesPerInput` (type: `integer`):

Use this when you need a pagination safety limit. Flipkart typically shows roughly 24 listing cards per page, but layouts vary. The listing cap normally stops first; this setting bounds requests when cards are filtered or repeated.

## `sortBy` (type: `string`):

Use this when search-query order matters. This setting is applied to generated keyword searches and does not rewrite a supplied listing URL. Choose relevance for Flipkart's default ranking or a price/popularity order for monitoring workflows.

## `minPrice` (type: `integer`):

Use this when you want only listing cards at or above an INR price. Filtering happens after extraction, so the source listing URL and its pagination remain unchanged. Leave empty to keep listings with any displayed price.

## `maxPrice` (type: `integer`):

Use this when you want only listing cards at or below an INR price. This is an actor-side filter rather than a promise that Flipkart's own facets use the same buckets. Leave empty to keep listings with any displayed price.

## `minRating` (type: `number`):

Use this when you only need products meeting a visible average-rating threshold from 0 to 5. Listings without a visible rating do not pass this filter. Leave empty to retain both rated and unrated listings.

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

Use this when you need to override the network route. Flipkart is geo-targeted and frequently challenges datacenter IPs, so this actor defaults to Apify Residential Proxy in India. Keep that default for reliable public listing access.

## Actor input object example

```json
{
  "searchQueries": [
    "wireless earbuds",
    "iphone 15 case"
  ],
  "listingUrls": [
    "https://www.flipkart.com/mobiles/pr?sid=tyy,4io"
  ],
  "maxItemsPerInput": 50,
  "maxTotalItems": 500,
  "maxPagesPerInput": 10,
  "sortBy": "price_asc",
  "minPrice": 1000,
  "maxPrice": 5000,
  "minRating": 4,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IN"
  }
}
```

# Actor output Schema

## `listings` (type: `string`):

Validated Flipkart listing records emitted by this run.

## `output` (type: `string`):

Stable OUTPUT key containing the terminal outcome and counts.

## `runSummary` (type: `string`):

RUN\_SUMMARY key with safe diagnostics and per-source counters.

# 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 = {
    "searchQueries": [
        "wireless earbuds"
    ],
    "listingUrls": [],
    "maxItemsPerInput": 50,
    "maxTotalItems": 500,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "IN"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/flipkart-listings-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 = {
    "searchQueries": ["wireless earbuds"],
    "listingUrls": [],
    "maxItemsPerInput": 50,
    "maxTotalItems": 500,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "IN",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/flipkart-listings-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 '{
  "searchQueries": [
    "wireless earbuds"
  ],
  "listingUrls": [],
  "maxItemsPerInput": 50,
  "maxTotalItems": 500,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IN"
  }
}' |
apify call khadinakbar/flipkart-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Flipkart Listings Scraper",
        "description": "Extract public Flipkart search and category listings: product titles, prices, MRP, discounts, ratings, images, availability, and source URLs. Batch queries or listing URLs in, structured listing cards out.",
        "version": "1.3",
        "x-build-id": "ii42EcavjmB2cVipu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~flipkart-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-flipkart-listings-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/khadinakbar~flipkart-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-flipkart-listings-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/khadinakbar~flipkart-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-flipkart-listings-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Use this when you want to discover products by keyword. Each query is run on Flipkart search, such as 'wireless earbuds' or 'gaming laptop'. You may combine this with listing URLs. The actor returns listing cards only; it does not open every product page for full specifications.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "listingUrls": {
                        "title": "Category or search URLs",
                        "type": "array",
                        "description": "Use this when you already have a public Flipkart search, category, browse, or collection URL. Each URL is paginated independently. Do not enter product detail URLs containing '/p/'; use the separate Flipkart Product Scraper for product-page details.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItemsPerInput": {
                        "title": "Maximum listings per input",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Use this when you need a predictable per-query or per-URL budget. The actor stops after this many validated listings for each input. Set a lower value for quick checks and a higher value for catalog exports. Each persisted listing is billed once.",
                        "default": 50
                    },
                    "maxTotalItems": {
                        "title": "Maximum total listings",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Use this when several inputs share one run budget. This hard cap applies across all queries and listing URLs, even when their combined per-input limits would be larger. It prevents accidental over-collection and caps per-listing event charges.",
                        "default": 500
                    },
                    "maxPagesPerInput": {
                        "title": "Maximum pages per input",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Use this when you need a pagination safety limit. Flipkart typically shows roughly 24 listing cards per page, but layouts vary. The listing cap normally stops first; this setting bounds requests when cards are filtered or repeated.",
                        "default": 10
                    },
                    "sortBy": {
                        "title": "Search sort order",
                        "enum": [
                            "relevance",
                            "price_asc",
                            "price_desc",
                            "popularity",
                            "newest"
                        ],
                        "type": "string",
                        "description": "Use this when search-query order matters. This setting is applied to generated keyword searches and does not rewrite a supplied listing URL. Choose relevance for Flipkart's default ranking or a price/popularity order for monitoring workflows.",
                        "default": "relevance"
                    },
                    "minPrice": {
                        "title": "Minimum price (INR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Use this when you want only listing cards at or above an INR price. Filtering happens after extraction, so the source listing URL and its pagination remain unchanged. Leave empty to keep listings with any displayed price."
                    },
                    "maxPrice": {
                        "title": "Maximum price (INR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Use this when you want only listing cards at or below an INR price. This is an actor-side filter rather than a promise that Flipkart's own facets use the same buckets. Leave empty to keep listings with any displayed price."
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Use this when you only need products meeting a visible average-rating threshold from 0 to 5. Listings without a visible rating do not pass this filter. Leave empty to retain both rated and unrated listings."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Use this when you need to override the network route. Flipkart is geo-targeted and frequently challenges datacenter IPs, so this actor defaults to Apify Residential Proxy in India. Keep that default for reliable public listing access.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "IN"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
