# RapidAPI Scraper (`maximedupre/rapidapi-scraper`) Actor

Scrape RapidAPI marketplace API listings from search, profile URLs, categories, or collections. Export names, providers, pricing, metrics, billing plans, documentation, and endpoint metadata.

- **URL**: https://apify.com/maximedupre/rapidapi-scraper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Developer tools, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 1,000 scraped api listings

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.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 for marketplace API data

RapidAPI Scraper collects public API listings from [RapidAPI](https://rapidapi.com/). Use this rapidapi scraper to search the marketplace by keyword, enrich exact API profile URLs, browse category names, or collect APIs from collection slugs such as `popular-apis`.

The Actor saves one dataset item per successfully scraped RapidAPI API listing or profile. Rows can include API IDs, canonical profile URLs, names, descriptions, categories, tags, provider facts, logo URLs, pricing labels, visibility/status fields, source update dates, score and performance metrics, billing plans, documentation, website links, and endpoint metadata when you request it.

You do not need a RapidAPI account, API key, cookies, or browser session. For a quick first run, keep `Target type` set to `Search keywords`, use the prefilled `weather` query, keep `Detail level` on `Basic listing`, and run a small result limit before raising it.

### ✅ What this Actor does

- Searches RapidAPI marketplace listings from one or more keywords.
- Scrapes exact RapidAPI API profile URLs.
- Browses RapidAPI category pages by category name.
- Browses RapidAPI collections by collection slug.
- Lets you choose basic listing data, detailed profile data, or detailed profile and endpoint data.
- Preserves source order for search, category, and collection discovery rows.
- Deduplicates the same API within a run.
- Saves only successful API rows, so status messages and skipped targets do not pollute the dataset.

This Actor is built for API discovery, competitor research, software market maps, developer tool research, and repeatable RapidAPI marketplace exports. It focuses on public marketplace data. It does not scrape private RapidAPI account data, subscriber-only data, API keys, account dashboards, or generated recommendations.

### 📦 Data you can extract

Each dataset item can include:

- `apiId`, `url`, `name`, `title`, and `slug`
- `description` and `longDescription`
- `categoryName`, `tags`, and `logoUrl`
- `position` for ordered search, category, and collection results
- `pricing`, `visibility`, `status`, `apiType`, `updatedAt`, and `createdAt`
- `provider` identity and provider profile links
- `metrics` such as score, popularity, latency, service level, and success rate when RapidAPI exposes them
- `version`, `billingPlans`, `billingItems`, `rating`, and `subscriptionsCount`
- `websiteUrl`, `termsOfServiceUrl`, and `documentation`
- `endpoints` with titles, methods, endpoint URLs, playground URLs, descriptions, parameters, and headers when endpoint enrichment is requested and the source exposes them

Some fields can be `null` or empty when RapidAPI does not show that fact for a listing or profile. Basic runs return marketplace listing fields. Detailed runs add profile, billing, rating, documentation, and endpoint groups when available.

### 🎯 Target options

Choose one target type per run.

`Search keywords` searches RapidAPI by use case, API type, provider name, or product keyword. Examples: `weather`, `translation`, `finance`, or `web search`.

`Profile URLs` enriches exact RapidAPI API profile URLs, such as `https://rapidapi.com/weatherapi/api/weatherapi-com`. Profile URL runs use your submitted URL list as the full scope.

`Categories` browses RapidAPI category pages by category name, such as `Data`, `Finance`, `Weather`, or `Tools`.

`Collections` browses RapidAPI collections by slug, such as `popular-apis` or `list-of-free-apis`.

Use `Sort results by`, `Order`, and `Maximum discovered APIs` for search, category, and collection discovery runs. Profile URL runs do not use discovery sorting because the submitted URLs define the scope.

### 🚀 How to run it

1. Open the Actor input.
2. Choose one `Target type`.
3. Fill the matching target section only.
4. Choose `Detail level`.
5. For discovery targets, set `Maximum discovered APIs`.
6. Run the Actor and open the dataset.

Start with `Basic listing` when you want a broad marketplace export. Use `Detailed profile` when you need billing plans, documentation, ratings, and profile facts. Use `Detailed profile and endpoints` when you also need public endpoint metadata.

You can export the dataset as JSON, CSV, Excel, XML, RSS, or HTML. You can also run the Actor through the Apify API, schedule repeat runs, or connect results to webhooks and integrations.

### 🧾 Output example

```json
{
	"apiId": "api_67a94d7b-c4c9-4b7f-ba0b-e4e474789a82",
	"url": "https://rapidapi.com/weatherapi/api/weatherapi-com",
	"name": "WeatherAPI.com",
	"title": "WeatherAPI.com",
	"slug": "weatherapi-com",
	"description": "Weather API with forecast, history, and astronomy data.",
	"longDescription": "Public profile description when detailed data is requested.",
	"categoryName": "Weather",
	"tags": ["Weather"],
	"logoUrl": "https://rapidapi-prod-apis.s3.amazonaws.com/example.png",
	"position": null,
	"pricing": "FREEMIUM",
	"visibility": "PUBLIC",
	"status": "ACTIVE",
	"apiType": "REST",
	"updatedAt": "2026-05-21T14:18:00Z",
	"createdAt": "2023-08-15T09:40:00Z",
	"provider": {
		"id": "weatherapi",
		"name": "WeatherAPI.com",
		"slug": "weatherapi",
		"type": "ORGANIZATION",
		"profileUrl": "https://rapidapi.com/weatherapi",
		"websiteUrl": "https://www.weatherapi.com/"
	},
	"metrics": {
		"score": null,
		"popularityScore": 98.2,
		"latencyMs": 312,
		"serviceLevelPercent": 99.9,
		"successRatePercent": 99.1
	},
	"billingPlans": [],
	"billingItems": [],
	"documentation": {
		"readme": "Public documentation text when RapidAPI exposes it.",
		"baseUrl": "https://weatherapi-com.p.rapidapi.com"
	},
	"endpoints": [
		{
			"title": "Forecast",
			"method": "GET",
			"url": "https://weatherapi-com.p.rapidapi.com/forecast.json",
			"playgroundUrl": "https://rapidapi.com/weatherapi/api/weatherapi-com/playground/apiendpoint_...",
			"description": "Forecast endpoint description.",
			"parameters": [
				{
					"name": "q",
					"in": "query",
					"required": true,
					"type": "string",
					"description": "Search query."
				}
			],
			"headers": []
		}
	]
}
````

### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged only for successful API items that are saved.

- `Scraped API listing` - charged for each basic marketplace listing item.
- `Scraped API profile` - charged for each profile, direct URL, or endpoint-enriched item.

There is no actor-start charge.

### ⚠️ Limits and caveats

RapidAPI categories, collections, rankings, and public profile fields can change over time. If RapidAPI does not expose a field for a specific API, the Actor leaves that field `null` or empty.

Endpoint metadata is returned only when `Detailed profile and endpoints` is selected and the endpoint data is public. The Actor does not call the APIs listed on RapidAPI, test endpoint availability, or verify that a provider's paid API plans still work.

For clearer exports, run one target type at a time. If you need search results and collection results, run the Actor twice and compare the datasets.

### ❓ FAQ

#### Do I need a RapidAPI account?

No. The Actor reads public RapidAPI marketplace data and does not ask for RapidAPI credentials, cookies, API keys, or a browser session.

#### Can I scrape one exact API profile?

Yes. Choose `Profile URLs`, paste one or more RapidAPI API profile URLs, and select the detail level you need.

#### Does it return endpoint parameters and headers?

Yes, when `Detailed profile and endpoints` is selected and RapidAPI exposes those endpoint facts publicly. Some APIs show fewer endpoint details than others.

#### Why should I run separate target types?

Separate runs keep scope, sorting, limits, and pricing easier to understand. Search, category, collection, and profile URL targets are still all supported by the same Actor.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~rapidapi-scraper/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [Chrome Extensions Scraper ↗](https://apify.com/maximedupre/chrome-extensions-scraper) - Collect Chrome Web Store extension data, manifests, permissions, ratings, and publisher contacts.
- [CodeCanyon Scraper ↗](https://apify.com/maximedupre/codecanyon-scraper) - Scrape Envato CodeCanyon item prices, sales, ratings, authors, categories, and item details.
- [G2 Products Scraper ↗](https://apify.com/maximedupre/g2-products-scraper) - Export public G2 product profiles, ratings, review counts, categories, pricing, and optional reviews.
- [WordPress Plugin Scraper ↗](https://apify.com/maximedupre/wordpress-plugin-scraper) - Collect WordPress.org plugin installs, ratings, compatibility, authors, support stats, media, and reviews.
- [Google Play Store Scraper ↗](https://apify.com/maximedupre/google-play-store-scraper) - Scrape Google Play app details, reviews, permissions, Data Safety data, ratings, and developer facts.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `targetType` (type: `string`):

Choose the RapidAPI surface this run collects from.

## `detailLevel` (type: `string`):

Choose how much source-backed API profile data to return.

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

Use when Target type is Search keywords.

## `apiUrls` (type: `array`):

Use when Target type is Profile URLs.

## `categories` (type: `array`):

Use when Target type is Categories.

## `collections` (type: `array`):

Use when Target type is Collections.

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

Source order for search, category, and collection targets.

## `order` (type: `string`):

Direction for discovery sorts that support it.

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

Maximum APIs to collect from the selected discovery target.

## Actor input object example

```json
{
  "targetType": "search",
  "detailLevel": "basic",
  "searchTerms": [
    "weather",
    "translation"
  ],
  "apiUrls": [
    "https://rapidapi.com/weatherapi/api/weatherapi-com"
  ],
  "categories": [
    "Data",
    "Finance"
  ],
  "collections": [
    "popular-apis",
    "list-of-free-apis"
  ],
  "sortBy": "ByRelevance",
  "order": "ASC",
  "maxResults": 450
}
```

# Actor output Schema

## `results` (type: `string`):

Open the dataset with one item for each successfully scraped RapidAPI API listing or profile.

# 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",
        "translation"
    ],
    "apiUrls": [
        "https://rapidapi.com/weatherapi/api/weatherapi-com"
    ],
    "categories": [
        "Data",
        "Finance"
    ],
    "collections": [
        "popular-apis",
        "list-of-free-apis"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/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",
        "translation",
    ],
    "apiUrls": ["https://rapidapi.com/weatherapi/api/weatherapi-com"],
    "categories": [
        "Data",
        "Finance",
    ],
    "collections": [
        "popular-apis",
        "list-of-free-apis",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/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",
    "translation"
  ],
  "apiUrls": [
    "https://rapidapi.com/weatherapi/api/weatherapi-com"
  ],
  "categories": [
    "Data",
    "Finance"
  ],
  "collections": [
    "popular-apis",
    "list-of-free-apis"
  ]
}' |
apify call maximedupre/rapidapi-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "RapidAPI Scraper",
        "description": "Scrape RapidAPI marketplace API listings from search, profile URLs, categories, or collections. Export names, providers, pricing, metrics, billing plans, documentation, and endpoint metadata.",
        "version": "0.1",
        "x-build-id": "Ut6Ootc2bhggtqA51"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~rapidapi-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-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/maximedupre~rapidapi-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-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/maximedupre~rapidapi-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-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",
                "required": [
                    "targetType"
                ],
                "properties": {
                    "targetType": {
                        "title": "Target type",
                        "enum": [
                            "search",
                            "profileUrls",
                            "categories",
                            "collections"
                        ],
                        "type": "string",
                        "description": "Choose the RapidAPI surface this run collects from.",
                        "default": "search"
                    },
                    "detailLevel": {
                        "title": "Detail level",
                        "enum": [
                            "basic",
                            "profile",
                            "profileAndEndpoints"
                        ],
                        "type": "string",
                        "description": "Choose how much source-backed API profile data to return.",
                        "default": "basic"
                    },
                    "searchTerms": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Use when Target type is Search keywords.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "apiUrls": {
                        "title": "RapidAPI profile URLs",
                        "type": "array",
                        "description": "Use when Target type is Profile URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categories": {
                        "title": "Categories",
                        "type": "array",
                        "description": "Use when Target type is Categories.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "collections": {
                        "title": "Collections",
                        "type": "array",
                        "description": "Use when Target type is Collections.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortBy": {
                        "title": "Sort results by",
                        "enum": [
                            "ByRelevance",
                            "ByTrending",
                            "ByUpdatedAt",
                            "ByAlphabetical"
                        ],
                        "type": "string",
                        "description": "Source order for search, category, and collection targets.",
                        "default": "ByRelevance"
                    },
                    "order": {
                        "title": "Order",
                        "enum": [
                            "ASC",
                            "DESC"
                        ],
                        "type": "string",
                        "description": "Direction for discovery sorts that support it.",
                        "default": "ASC"
                    },
                    "maxResults": {
                        "title": "Maximum discovered APIs",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum APIs to collect from the selected discovery target.",
                        "default": 450
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```