# ASO Keyword Rank Tracker (`automation-lab/aso-keyword-rank-tracker`) Actor

Track Google Play keyword ranks for Android package IDs by country/language. Export rank positions, matched app metadata, and top competitors.

- **URL**: https://apify.com/automation-lab/aso-keyword-rank-tracker.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## ASO Keyword Rank Tracker

Track Google Play keyword rankings for one or more Android apps by package ID, country, and language.

### What does ASO Keyword Rank Tracker do?

ASO Keyword Rank Tracker checks Google Play public search results and tells you where your target app appears for each keyword.

It accepts Google Play package IDs such as `com.myfitnesspal.android`, a list of ASO keywords, and locale settings.

For every app and keyword combination, it outputs the detected rank, matched title, developer, rating, Google Play URL, status, and a sample of top competing results.

### Who is it for?

- 📱 ASO teams monitoring app visibility.
- 📈 Mobile marketers reporting keyword movement.
- 🧑‍💼 Agencies checking client and competitor apps.
- 🧪 Indie developers validating keyword experiments.
- 🧰 Data teams feeding rank checks into dashboards.

### Why use this actor?

Google Play rankings vary by keyword, country, and language. Manual checking is slow and difficult to repeat.

This actor gives you structured rows that can be exported to CSV, JSON, Google Sheets, BI tools, or your own monitoring system.

### Google Play data covered

The actor reads public Google Play search result pages.

It does not require a Google account.

It does not install apps, use private APIs, or access user data.

### Data table

| Field | Description |
| --- | --- |
| `keyword` | Keyword searched on Google Play |
| `country` | Google Play `gl` country code |
| `language` | Google Play `hl` language code |
| `appId` | Target package ID |
| `foundRank` | Rank position, or `null` when not found |
| `foundUrl` | Google Play app URL |
| `matchedTitle` | App title from the matched card |
| `matchedDeveloper` | Developer name from the matched card |
| `matchedRating` | Rating visible in search results |
| `checkedAt` | ISO timestamp of the check |
| `resultsScanned` | Number of unique apps parsed |
| `topResults` | Competitor sample from the top results |
| `status` | `FOUND`, `NOT_FOUND`, or `ERROR` |
| `error` | Error message when a keyword check fails |

### How much does it cost to track Google Play ASO keyword ranks?

The actor uses pay-per-event pricing.

You pay a small run-start event plus one result event for each app + keyword row produced.

For example, 2 apps × 5 keywords creates 10 output rows.

Final live prices are visible on the Apify actor page before you run it.

### Quick start

1. Open the actor on Apify.
2. Enter one or more Google Play package IDs.
3. Add your ASO keywords.
4. Choose country and language.
5. Run the actor.
6. Export the dataset.

### Input: app IDs

Use Android package IDs, not full URLs.

Good examples:

- `com.myfitnesspal.android`
- `com.google.android.apps.fitness`
- `com.fitbit.FitbitMobile`

### Input: keywords

Use the exact phrases you want to monitor.

Examples:

- `calorie counter`
- `fitness tracker`
- `workout app`
- `meditation`

### Input: country and language

`country` maps to the Google Play `gl` parameter.

`language` maps to the Google Play `hl` parameter.

Examples:

- United States English: `country=US`, `language=en`
- Germany German: `country=DE`, `language=de`
- France French: `country=FR`, `language=fr`

### Input: rank depth

`maxRankDepth` controls how many unique apps are scanned per keyword.

Use a small depth for cheap smoke tests.

Use a larger depth for production monitoring.

### Output: found ranks

When the target app appears in the parsed Google Play results, `foundRank` is a 1-based rank.

When it does not appear, `foundRank` is `null` and `status` is `NOT_FOUND`.

### Output: competitor sample

`topResults` includes a small list of top apps for the keyword.

This helps you understand who is ranking ahead of your app without running a separate competitor scraper.

### Example input

```json
{
  "appIds": ["com.myfitnesspal.android", "com.google.android.apps.fitness"],
  "keywords": ["calorie counter", "fitness tracker"],
  "country": "US",
  "language": "en",
  "maxRankDepth": 30,
  "includeTopResults": 10
}
````

### Example output

```json
{
  "keyword": "calorie counter",
  "country": "US",
  "language": "en",
  "appId": "com.myfitnesspal.android",
  "foundRank": 1,
  "foundUrl": "https://play.google.com/store/apps/details?id=com.myfitnesspal.android",
  "matchedTitle": "MyFitnessPal: Calorie Counter",
  "matchedDeveloper": "MyFitnessPal, Inc.",
  "matchedRating": 4.4,
  "checkedAt": "2026-06-25T00:00:00.000Z",
  "resultsScanned": 30,
  "status": "FOUND"
}
```

### Tips for better ASO monitoring

- ✅ Keep keyword batches focused.
- ✅ Use the same country/language for trend comparisons.
- ✅ Store historical datasets for movement over time.
- ✅ Track competitor package IDs alongside your own app.
- ✅ Use `NOT_FOUND` rows to detect missed visibility.

### Integrations

Use the output dataset with:

- Google Sheets dashboards.
- Looker Studio reports.
- Slack alerts for rank drops.
- Airtable keyword tracking tables.
- BigQuery or Snowflake warehouses.
- Scheduled Apify tasks for recurring ASO monitoring.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/aso-keyword-rank-tracker').call({
  appIds: ['com.myfitnesspal.android'],
  keywords: ['calorie counter'],
  country: 'US',
  language: 'en',
  maxRankDepth: 30
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/aso-keyword-rank-tracker').call(run_input={
    'appIds': ['com.myfitnesspal.android'],
    'keywords': ['calorie counter'],
    'country': 'US',
    'language': 'en',
    'maxRankDepth': 30,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~aso-keyword-rank-tracker/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"appIds":["com.myfitnesspal.android"],"keywords":["calorie counter"],"country":"US","language":"en","maxRankDepth":30}'
```

### MCP for Claude Code and Claude Desktop

You can connect this actor through Apify MCP.

Use this MCP URL:

`https://mcp.apify.com/?tools=automation-lab/aso-keyword-rank-tracker`

Claude Code setup:

```bash
claude mcp add apify-aso-keyword-rank-tracker https://mcp.apify.com/?tools=automation-lab/aso-keyword-rank-tracker
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-aso-keyword-rank-tracker": {
      "url": "https://mcp.apify.com/?tools=automation-lab/aso-keyword-rank-tracker"
    }
  }
}
```

Example prompts:

- "Check my Android app rank for these ASO keywords in the US."
- "Compare these competitor package IDs for workout app keywords."
- "Create a CSV of Google Play keyword ranks for my weekly ASO report."

### Scheduling recurring rank checks

Create an Apify task with your package IDs and keywords.

Schedule it daily or weekly.

Export each run's dataset to your reporting stack.

### FAQ

Common questions about ASO rank tracking, Google Play package IDs, and recurring keyword monitoring.

### Troubleshooting: why is my app not found?

The app may rank below the selected depth, not rank for the keyword, or Google Play may personalize/adjust results by country and language.

Increase `maxRankDepth` or verify the package ID.

### Troubleshooting: why do ranks change?

Google Play rankings can change due to personalization, experiments, country, language, and time.

For trend reporting, keep inputs consistent.

### Limitations

The actor currently targets Google Play search results.

It does not yet check Apple App Store rankings.

It parses public search pages, so fields depend on what Google Play exposes in the page response.

### Legality and responsible use

This actor extracts publicly available Google Play search result information.

Use it responsibly, respect applicable laws, and avoid abusive request volumes.

### Related scrapers

Related automation-lab actors:

- https://apify.com/automation-lab/google-autocomplete-scraper
- https://apify.com/automation-lab/google-search-results-scraper
- https://apify.com/automation-lab/app-store-reviews-scraper

### Support

If a keyword or country stops returning results, open an Apify issue with your input and run ID.

### Changelog

- `0.1` Initial Google Play ASO keyword rank tracking MVP.

# Actor input Schema

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

Package IDs to look for in Google Play search results, for example com.myfitnesspal.android.

## `keywords` (type: `array`):

Keywords to search on Google Play. The actor emits one row for every app + keyword combination.

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

Google Play country code used as the gl parameter.

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

Google Play interface language used as the hl parameter.

## `maxRankDepth` (type: `integer`):

How many unique Google Play app results to scan per keyword.

## `includeTopResults` (type: `integer`):

How many top-ranked apps to include in each output row for competitor snapshots.

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

Optional Apify Proxy settings. Leave disabled unless your checks are rate-limited from your location.

## Actor input object example

```json
{
  "appIds": [
    "com.myfitnesspal.android",
    "com.google.android.apps.fitness"
  ],
  "keywords": [
    "calorie counter",
    "fitness tracker"
  ],
  "country": "US",
  "language": "en",
  "maxRankDepth": 20,
  "includeTopResults": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "appIds": [
        "com.myfitnesspal.android",
        "com.google.android.apps.fitness"
    ],
    "keywords": [
        "calorie counter",
        "fitness tracker"
    ],
    "country": "US",
    "language": "en",
    "maxRankDepth": 20,
    "includeTopResults": 10,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/aso-keyword-rank-tracker").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 = {
    "appIds": [
        "com.myfitnesspal.android",
        "com.google.android.apps.fitness",
    ],
    "keywords": [
        "calorie counter",
        "fitness tracker",
    ],
    "country": "US",
    "language": "en",
    "maxRankDepth": 20,
    "includeTopResults": 10,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/aso-keyword-rank-tracker").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 '{
  "appIds": [
    "com.myfitnesspal.android",
    "com.google.android.apps.fitness"
  ],
  "keywords": [
    "calorie counter",
    "fitness tracker"
  ],
  "country": "US",
  "language": "en",
  "maxRankDepth": 20,
  "includeTopResults": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/aso-keyword-rank-tracker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ASO Keyword Rank Tracker",
        "description": "Track Google Play keyword ranks for Android package IDs by country/language. Export rank positions, matched app metadata, and top competitors.",
        "version": "0.1",
        "x-build-id": "lzlzIaBvY0iir4I4X"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~aso-keyword-rank-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-aso-keyword-rank-tracker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~aso-keyword-rank-tracker/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-aso-keyword-rank-tracker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~aso-keyword-rank-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-aso-keyword-rank-tracker",
                "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": [
                    "appIds",
                    "keywords"
                ],
                "properties": {
                    "appIds": {
                        "title": "Google Play app package IDs",
                        "minItems": 1,
                        "type": "array",
                        "description": "Package IDs to look for in Google Play search results, for example com.myfitnesspal.android.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywords": {
                        "title": "ASO keywords",
                        "minItems": 1,
                        "type": "array",
                        "description": "Keywords to search on Google Play. The actor emits one row for every app + keyword combination.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Google Play country code used as the gl parameter.",
                        "default": "US"
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Google Play interface language used as the hl parameter.",
                        "default": "en"
                    },
                    "maxRankDepth": {
                        "title": "Maximum rank depth",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How many unique Google Play app results to scan per keyword.",
                        "default": 20
                    },
                    "includeTopResults": {
                        "title": "Top results sample size",
                        "minimum": 0,
                        "maximum": 30,
                        "type": "integer",
                        "description": "How many top-ranked apps to include in each output row for competitor snapshots.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy settings. Leave disabled unless your checks are rate-limited from your location."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```