# RapidAPI Scraper (`automation-lab/rapidapi-scraper`) Actor

Extract public RapidAPI Marketplace API listings, providers, pricing labels, rankings, and quality signals for API discovery workflows.

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

## RapidAPI Scraper

Extract public RapidAPI Marketplace API search results, provider details, ranking metadata, and visible quality signals for API discovery workflows.

RapidAPI Scraper helps developers and data teams turn RapidAPI Marketplace searches into structured datasets.

Use it to monitor API categories, discover competing API providers, enrich internal API catalogs, and build lead lists from public marketplace data.

### What does RapidAPI Scraper do?

RapidAPI Scraper searches the public RapidAPI Marketplace.

It opens RapidAPI search pages in a browser.

It captures the public marketplace data used to render search results.

It saves one dataset row per API product.

Each row includes the API title, provider, category, description, pricing type, URL, ranking metadata, and quality scores when RapidAPI exposes them.

You can run broad keyword searches such as `weather`, `email validation`, or `translation`.

You can also provide RapidAPI search URLs directly.

### Who is it for?

#### Developer relations teams

Find API providers in a category and track how they position their products.

#### API product teams

Monitor competing APIs, pricing labels, category changes, and listing descriptions.

#### Data enrichment teams

Build a structured catalog of APIs for internal search, procurement, or vendor intelligence.

#### Lead generation teams

Find public provider profiles and marketplace URLs for API vendors in a target niche.

#### Researchers and analysts

Export RapidAPI Marketplace search results to CSV, JSON, Excel, or your own data warehouse.

### Why use this actor?

RapidAPI pages are designed for browsing, not bulk analysis.

Manual copying is slow.

Search results change over time.

A repeatable scraper gives you a timestamped dataset you can compare across runs.

The actor captures both visible listing fields and metadata from RapidAPI's public search payload.

It also includes fallback DOM extraction if the payload format changes.

### Data you can extract

| Field | Description |
| --- | --- |
| `title` | API listing title |
| `providerName` | Provider or organization name |
| `category` | RapidAPI category |
| `description` | Public API listing description |
| `pricing` | Visible pricing model such as FREEMIUM |
| `profileUrl` | RapidAPI API profile URL |
| `playgroundUrl` | RapidAPI playground URL |
| `popularityScore` | RapidAPI score when visible |
| `averageLatencyMs` | Latency signal when visible |
| `averageSuccessRate` | Success-rate signal when visible |
| `rank` | Rank within the captured search results |
| `totalResults` | Total results reported for the search |
| `searchTerm` | Query that produced the row |
| `scrapedAt` | Timestamp for the row |

### How much does it cost to scrape RapidAPI Marketplace?

This actor uses pay-per-event pricing.

There is a small start charge per run.

There is a per-item charge for each API record saved.

The current scaffold pricing is:

- Start: `$0.005` per run.
- Item: tiered per saved API record, starting at `$0.001` on BRONZE.

Final production pricing is validated from measured Apify run costs before publication.

Keep `maxItems` small for first tests.

### Input options

#### `searchTerms`

List of RapidAPI Marketplace queries.

Example:

```json
["weather", "email validation", "translation"]
````

#### `startUrls`

RapidAPI search URLs or API profile/playground URLs.

Example:

```json
[{ "url": "https://rapidapi.com/search?term=weather&sortBy=ByRelevance" }]
```

#### `maxItems`

Maximum API records to save across all inputs.

Use a low number for smoke tests.

Use a larger number for category monitoring.

#### `maxScrolls`

Number of scroll passes per search page.

More scrolls may reveal more lazy-loaded results.

#### `includeApiDetails`

Open each API detail/playground page and save a short visible text snippet.

This is slower and uses more compute.

### Example input: search intent

```json
{
  "searchTerms": ["weather"],
  "maxItems": 25,
  "maxScrolls": 2,
  "includeApiDetails": false
}
```

### Example input: competitive monitoring

```json
{
  "searchTerms": ["email validation", "phone validation", "address validation"],
  "maxItems": 75,
  "maxScrolls": 2,
  "includeApiDetails": false
}
```

### Example input: source-specific URL

```json
{
  "startUrls": [
    { "url": "https://rapidapi.com/search?term=translation&sortBy=ByRelevance" }
  ],
  "searchTerms": [],
  "maxItems": 30,
  "maxScrolls": 1
}
```

### Example output

```json
{
  "title": "Open Weather",
  "providerName": "Quantum APIs",
  "category": "Weather",
  "pricing": "FREEMIUM",
  "profileUrl": "https://rapidapi.com/worldapi/api/open-weather13",
  "description": "Get real-time weather data for any location worldwide!",
  "popularityScore": 9.9,
  "averageLatencyMs": 356,
  "averageSuccessRate": 100,
  "searchTerm": "weather",
  "rank": 2,
  "totalResults": 491,
  "scrapedAt": "2026-06-20T20:36:18.354Z"
}
```

### How to run

1. Open the actor on Apify.

2. Enter one or more RapidAPI search terms.

3. Set `maxItems` to the maximum number of API listings you need.

4. Leave `includeApiDetails` off for faster search exports.

5. Start the run.

6. Download the dataset as JSON, CSV, Excel, XML, or RSS.

### Tips for best results

Use specific keywords.

Search `email validation` instead of only `email`.

Run multiple adjacent keywords for a complete category view.

Keep scheduled monitoring runs consistent so rank changes are comparable.

Use `includeApiDetails` only when you need page snippets.

### Integrations

Send the dataset to Google Sheets for API lead review.

Export CSV into Airtable for provider tracking.

Load JSON into a warehouse for competitive intelligence dashboards.

Use webhooks to trigger alerts when a scheduled run finishes.

Combine with your CRM enrichment workflow to track API vendors.

### 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/rapidapi-scraper').call({
  searchTerms: ['weather'],
  maxItems: 25,
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/rapidapi-scraper').call(run_input={
    'searchTerms': ['weather'],
    'maxItems': 25,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~rapidapi-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"searchTerms":["weather"],"maxItems":25}'
```

### MCP usage

Use the actor through Apify MCP when you want an AI assistant to collect RapidAPI marketplace data directly from Claude Desktop or another MCP client.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/rapidapi-scraper
```

Add the Apify MCP server from the command line:

```bash
claude mcp add apify "https://mcp.apify.com/?tools=automation-lab/rapidapi-scraper"
```

Or add this MCP server configuration manually:

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

Example prompts:

- "Find the top RapidAPI APIs for email validation and summarize providers."
- "Scrape RapidAPI weather APIs and return a CSV-ready table."
- "Monitor translation APIs on RapidAPI and highlight pricing labels."

### Legality and responsible use

This actor extracts public marketplace information.

Do not use it to collect private account data.

Do not bypass authentication or access controls.

Respect RapidAPI terms and applicable laws.

Run at polite volumes.

### Limitations

RapidAPI uses Cloudflare and client-side rendering.

The actor uses a browser to access public search pages reliably.

Very large result collection may require multiple search terms or future pagination improvements.

Some fields are optional because RapidAPI may not expose every score for every API.

Search ranking can change between runs.

### Troubleshooting

#### I got fewer items than expected

Increase `maxScrolls` or add more specific search terms.

RapidAPI may only render a bounded first set for some searches.

#### The run is slower with detail pages

Disable `includeApiDetails` unless you need detail snippets.

Opening each profile page costs extra browser time.

#### Some fields are missing

RapidAPI does not expose every score, tag, or provider field for every listing.

Optional fields are omitted when unavailable.

### Related scrapers

Use related Automation Labs actors when your workflow moves beyond API marketplace data:

- https://apify.com/automation-lab/website-contact-finder
- https://apify.com/automation-lab/bulk-url-status-checker

Future developer-tools actors should cross-link to RapidAPI Scraper for API marketplace discovery.

### FAQ

#### Can I scrape any RapidAPI category?

Yes. Use search terms that match the category or workflow you care about.

#### Does this require a RapidAPI login?

No. The actor targets public marketplace pages.

#### Can I schedule monitoring?

Yes. Schedule the actor with the same input and compare datasets over time.

#### Can I collect provider contact details?

This actor only saves public marketplace provider names and URLs. Use a separate contact enrichment workflow if needed.

#### Is browser mode necessary?

Yes for this target. RapidAPI search records are hydrated through browser requests, so Playwright is more reliable than plain HTML parsing.

# Actor input Schema

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

RapidAPI Marketplace queries to search, such as weather, email validation, or translation.

## `startUrls` (type: `array`):

Optional RapidAPI Marketplace search URLs or API profile/playground URLs. Search URLs should contain a term parameter.

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

Maximum API records to save across all search terms and start URLs.

## `maxScrolls` (type: `integer`):

How many times to scroll each search page to trigger lazy-loaded results.

## `includeApiDetails` (type: `boolean`):

Visit each API playground/profile page and include a visible page text snippet. This is slower and costs more compute.

## Actor input object example

```json
{
  "searchTerms": [
    "weather",
    "email validation"
  ],
  "startUrls": [
    {
      "url": "https://rapidapi.com/search?term=weather&sortBy=ByRelevance"
    }
  ],
  "maxItems": 20,
  "maxScrolls": 2,
  "includeApiDetails": 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 = {
    "searchTerms": [
        "weather",
        "email validation"
    ],
    "startUrls": [
        {
            "url": "https://rapidapi.com/search?term=weather&sortBy=ByRelevance"
        }
    ],
    "maxItems": 20,
    "maxScrolls": 2,
    "includeApiDetails": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/rapidapi-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": [
        "weather",
        "email validation",
    ],
    "startUrls": [{ "url": "https://rapidapi.com/search?term=weather&sortBy=ByRelevance" }],
    "maxItems": 20,
    "maxScrolls": 2,
    "includeApiDetails": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/rapidapi-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": [
    "weather",
    "email validation"
  ],
  "startUrls": [
    {
      "url": "https://rapidapi.com/search?term=weather&sortBy=ByRelevance"
    }
  ],
  "maxItems": 20,
  "maxScrolls": 2,
  "includeApiDetails": false
}' |
apify call automation-lab/rapidapi-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "RapidAPI Scraper",
        "description": "Extract public RapidAPI Marketplace API listings, providers, pricing labels, rankings, and quality signals for API discovery workflows.",
        "version": "0.1",
        "x-build-id": "xG3ajndHLKiyynvP8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~rapidapi-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-rapidapi-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~rapidapi-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-rapidapi-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~rapidapi-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-rapidapi-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": "RapidAPI Marketplace queries to search, such as weather, email validation, or translation.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Optional RapidAPI Marketplace search URLs or API profile/playground URLs. Search URLs should contain a term parameter.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum APIs",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum API records to save across all search terms and start URLs.",
                        "default": 50
                    },
                    "maxScrolls": {
                        "title": "Scroll passes per search page",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many times to scroll each search page to trigger lazy-loaded results.",
                        "default": 2
                    },
                    "includeApiDetails": {
                        "title": "Open API detail pages",
                        "type": "boolean",
                        "description": "Visit each API playground/profile page and include a visible page text snippet. This is slower and costs more compute.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```