# Google Play Store Scraper (`crawlerbros/google-playstore-scraper`) Actor

Scrape Google Play Store app data including ratings, reviews, installs, pricing, developer info, and screenshots. Search by keyword or look up apps by package ID.

- **URL**: https://apify.com/crawlerbros/google-playstore-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Other, Integrations, Developer tools
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 15 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.50 / 1,000 results

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

## Google Play Store Scraper

Extract detailed app data from Google Play Store. Search by keyword or look up specific apps by package ID. Get ratings, reviews, install counts, developer info, screenshots, and 30+ data fields for each app.

### What does Google Play Store Scraper do?

This scraper collects comprehensive data from the Google Play Store. It supports two modes of operation:

- **Search mode** - Enter search keywords (e.g., "calculator", "fitness tracker") to discover and scrape matching apps
- **Direct lookup mode** - Provide specific app package IDs (e.g., "com.whatsapp") to scrape exact apps

For each app, the scraper extracts over 30 data points including ratings, reviews, install counts, pricing, developer contact information, screenshots, and more.

### Features

- Search Google Play Store by keyword
- Look up specific apps by package ID
- Extract 30+ fields per app including all metadata
- Optionally fetch user reviews with ratings and reply data
- Support for any country and language
- No proxy or authentication required
- Lightweight and fast

### Input

| Field | Type | Description | Default |
|-------|------|-------------|---------|
| searchTerms | array | Search keywords to find apps | - |
| appIds | array | Direct app package IDs for lookup | - |
| country | string | Two-letter country code (e.g., "us", "gb", "de") | "us" |
| language | string | Two-letter language code (e.g., "en", "es", "fr") | "en" |
| maxResults | integer | Maximum number of apps to scrape | 50 |
| includeReviews | boolean | Fetch user reviews for each app | false |
| reviewCount | integer | Number of reviews per app (1-200) | 20 |

You must provide at least one search term or app ID.

#### Input example

```json
{
    "searchTerms": ["photo editor", "calculator"],
    "country": "us",
    "language": "en",
    "maxResults": 10,
    "includeReviews": true,
    "reviewCount": 5
}
````

#### Direct app lookup example

```json
{
    "appIds": ["com.whatsapp", "com.google.android.calculator"],
    "country": "us",
    "language": "en"
}
```

### Output

Each app in the dataset contains the following fields:

| Field | Type | Description |
|-------|------|-------------|
| appId | string | Package ID (e.g., com.whatsapp) |
| title | string | App name |
| url | string | Google Play Store URL |
| developer | string | Developer name |
| developerId | string | Developer ID on Google Play |
| developerEmail | string | Developer contact email |
| developerWebsite | string | Developer website URL |
| developerAddress | string | Developer physical address |
| score | number | Average rating (0-5) |
| ratings | integer | Total number of ratings |
| reviewCount | integer | Total number of reviews |
| histogram | array | Rating distribution \[1-star through 5-star counts] |
| installs | string | Install count display text (e.g., "1,000,000+") |
| minInstalls | integer | Minimum install threshold |
| realInstalls | integer | Estimated real install count |
| price | number | App price (0 for free) |
| free | boolean | Whether the app is free |
| currency | string | Price currency code |
| genre | string | App category (e.g., Tools, Games) |
| genreId | string | Genre identifier |
| categories | array | List of categories |
| icon | string | App icon URL |
| headerImage | string | Feature/header image URL |
| screenshots | array | Screenshot image URLs |
| video | string | Promo video URL |
| contentRating | string | Content rating (e.g., Everyone, Teen) |
| adSupported | boolean | Whether app shows ads |
| containsAds | boolean | Marked as containing ads |
| released | string | Original release date |
| lastUpdated | string | Date of last update |
| version | string | Current version number |
| description | string | Full app description |
| recentChanges | string | Latest changelog / what's new |
| privacyPolicy | string | Privacy policy URL |
| reviews | array | User reviews (when includeReviews is enabled) |
| scrapedAt | string | ISO 8601 scrape timestamp |

#### Review fields (when includeReviews is enabled)

Each review object contains:

| Field | Type | Description |
|-------|------|-------------|
| reviewId | string | Unique review identifier |
| userName | string | Reviewer's display name |
| userImage | string | Reviewer's profile image URL |
| score | integer | Rating given (1-5) |
| content | string | Review text |
| thumbsUpCount | integer | Number of helpful votes |
| date | string | Date the review was posted |
| replyContent | string | Developer's reply text |
| repliedAt | string | Date of developer's reply |
| appVersion | string | App version the review was written for |

#### Output example

```json
{
    "appId": "com.google.android.calculator",
    "title": "Calculator",
    "url": "https://play.google.com/store/apps/details?id=com.google.android.calculator",
    "developer": "Google LLC",
    "developerId": "5700313618786177705",
    "developerEmail": "apps-help@google.com",
    "developerWebsite": "https://support.google.com/calculator",
    "developerAddress": "1600 Amphitheatre Parkway, Mountain View 94043",
    "score": 4.32,
    "ratings": 1234567,
    "reviewCount": 98765,
    "histogram": [50000, 30000, 40000, 150000, 964567],
    "installs": "1,000,000,000+",
    "minInstalls": 1000000000,
    "realInstalls": 1523456789,
    "price": 0,
    "free": true,
    "currency": "USD",
    "genre": "Tools",
    "genreId": "TOOLS",
    "categories": [{"name": "Tools", "id": "TOOLS"}],
    "icon": "https://play-lh.googleusercontent.com/...",
    "headerImage": "https://play-lh.googleusercontent.com/...",
    "screenshots": ["https://play-lh.googleusercontent.com/..."],
    "video": "",
    "contentRating": "Everyone",
    "adSupported": false,
    "containsAds": false,
    "released": "Oct 22, 2014",
    "lastUpdated": "2025-01-15 00:00:00",
    "version": "8.8",
    "description": "A simple calculator app...",
    "recentChanges": "Bug fixes and performance improvements",
    "privacyPolicy": "https://policies.google.com/privacy",
    "reviews": [],
    "scrapedAt": "2025-06-15T12:00:00+00:00"
}
```

### How much does it cost to use Google Play Store Scraper?

This scraper is lightweight and efficient. It uses pure HTTP requests with no browser automation, which keeps costs minimal.

| Apps | Approx. time | Approx. cost |
|------|-------------|-------------|
| 10 apps | ~30 seconds | < $0.01 |
| 50 apps | ~2 minutes | < $0.05 |
| 50 apps + reviews | ~4 minutes | < $0.10 |

No proxy is required, further reducing operational costs.

### Tips and best practices

- **Start small** - Use a low `maxResults` value (5-10) for initial testing before scaling up
- **Country matters** - Some apps are only available in specific countries. Set the `country` field accordingly
- **Reviews add time** - Enabling reviews increases run time. Use `reviewCount` to limit how many reviews per app
- **Combine modes** - You can use both `searchTerms` and `appIds` in the same run
- **Rate limiting** - The scraper automatically manages request pacing to avoid being blocked

### Frequently Asked Questions

#### Can I scrape any app on Google Play Store?

Yes, any publicly listed app on Google Play Store can be scraped. Apps that are region-restricted will only appear when using the appropriate country code.

#### Do I need a Google account or API key?

No. This scraper works without any authentication, API keys, or cookies.

#### Do I need a proxy?

No. The scraper works reliably without a proxy from any IP address.

#### How many apps can I scrape in one run?

You can scrape up to 250 apps per run. Each search term returns up to 50 results from Google Play.

#### Can I get reviews for all apps?

Yes, enable the `includeReviews` option and set `reviewCount` to the number of reviews you want per app (up to 200).

#### What countries and languages are supported?

All countries and languages supported by Google Play Store are available. Use standard two-letter codes (e.g., "us", "gb", "de" for countries; "en", "es", "fr" for languages).

#### How often is the data updated?

The scraper fetches live data directly from Google Play Store on each run. Data is always current at the time of scraping.

#### Why are some fields empty for certain apps?

Some apps may not have all fields populated on Google Play Store (e.g., no promo video, no developer address). The scraper returns empty strings or empty arrays for unavailable fields.

# Actor input Schema

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

List of search keywords to find apps on Google Play Store (e.g., "calculator", "fitness tracker", "photo editor")

## `appIds` (type: `array`):

List of Google Play app package IDs for direct lookup (e.g., "com.google.android.calculator", "com.whatsapp")

## `country` (type: `string`):

Country for localized results, pricing, and availability.

## `language` (type: `string`):

Language for app descriptions and reviews.

## `maxResults` (type: `integer`):

Maximum number of apps to scrape across all search terms

## `includeReviews` (type: `boolean`):

Fetch user reviews for each app. Increases run time.

## `reviewCount` (type: `integer`):

Number of reviews to fetch per app (only used when Include Reviews is enabled)

## Actor input object example

```json
{
  "searchTerms": [
    "calculator"
  ],
  "country": "us",
  "language": "en",
  "maxResults": 5,
  "includeReviews": false,
  "reviewCount": 20
}
```

# Actor output Schema

## `apps` (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 = {
    "searchTerms": [
        "calculator"
    ],
    "country": "us",
    "language": "en",
    "maxResults": 5,
    "reviewCount": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/google-playstore-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 = {
    "searchTerms": ["calculator"],
    "country": "us",
    "language": "en",
    "maxResults": 5,
    "reviewCount": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/google-playstore-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 '{
  "searchTerms": [
    "calculator"
  ],
  "country": "us",
  "language": "en",
  "maxResults": 5,
  "reviewCount": 20
}' |
apify call crawlerbros/google-playstore-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Play Store Scraper",
        "description": "Scrape Google Play Store app data including ratings, reviews, installs, pricing, developer info, and screenshots. Search by keyword or look up apps by package ID.",
        "version": "1.0",
        "x-build-id": "OLTQvFd9kQosoYvXJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~google-playstore-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-google-playstore-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/crawlerbros~google-playstore-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-google-playstore-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/crawlerbros~google-playstore-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-google-playstore-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": {
                    "searchTerms": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "List of search keywords to find apps on Google Play Store (e.g., \"calculator\", \"fitness tracker\", \"photo editor\")",
                        "items": {
                            "type": "string"
                        }
                    },
                    "appIds": {
                        "title": "App IDs",
                        "type": "array",
                        "description": "List of Google Play app package IDs for direct lookup (e.g., \"com.google.android.calculator\", \"com.whatsapp\")",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "us",
                            "gb",
                            "ca",
                            "au",
                            "in",
                            "de",
                            "fr",
                            "es",
                            "it",
                            "jp",
                            "kr",
                            "br",
                            "mx",
                            "nl",
                            "be",
                            "at",
                            "ch",
                            "se",
                            "no",
                            "dk",
                            "fi",
                            "pl",
                            "pt",
                            "cz",
                            "ro",
                            "hu",
                            "gr",
                            "tr",
                            "ru",
                            "ua",
                            "za",
                            "eg",
                            "ng",
                            "ke",
                            "id",
                            "th",
                            "vn",
                            "ph",
                            "my",
                            "sg",
                            "tw",
                            "hk",
                            "nz",
                            "ar",
                            "cl",
                            "co",
                            "pe",
                            "il",
                            "ae",
                            "sa"
                        ],
                        "type": "string",
                        "description": "Country for localized results, pricing, and availability.",
                        "default": "us"
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "es",
                            "fr",
                            "de",
                            "it",
                            "pt",
                            "ja",
                            "ko",
                            "zh",
                            "ru",
                            "ar",
                            "hi",
                            "th",
                            "vi",
                            "id",
                            "tr",
                            "pl",
                            "nl",
                            "sv",
                            "da",
                            "no",
                            "fi",
                            "cs",
                            "ro",
                            "hu",
                            "el",
                            "he",
                            "uk",
                            "ms",
                            "tl"
                        ],
                        "type": "string",
                        "description": "Language for app descriptions and reviews.",
                        "default": "en"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 250,
                        "type": "integer",
                        "description": "Maximum number of apps to scrape across all search terms",
                        "default": 50
                    },
                    "includeReviews": {
                        "title": "Include Reviews",
                        "type": "boolean",
                        "description": "Fetch user reviews for each app. Increases run time.",
                        "default": false
                    },
                    "reviewCount": {
                        "title": "Reviews Per App",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Number of reviews to fetch per app (only used when Include Reviews is enabled)",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
