# RapidAPI Hub Scraper: API Listings, Metrics and Developer Data (`getascraper/rapidapi-scraper`) Actor

Extract API marketplace listings from RapidAPI Hub. Get category, pricing model, success rate, latency, subscriptions, and full developer profile for thousands of public APIs. Filter by category, pricing model, or quality threshold.

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

## Pricing

from $0.59 / 1,000 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.
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

### What does RapidAPI Hub Scraper do?

Pull structured data from the RapidAPI Hub marketplace — the world's largest public API directory, with over 40,000 APIs across every category. No account, login, or API key required.

1. Connects to the RapidAPI Hub and discovers all featured and category API listings automatically.
2. Applies your filters including category, pricing model, minimum success rate, and maximum latency.
3. Returns a clean, flat dataset with one row per API, including developer profile and performance scores.
4. Optionally visits each API's profile page to collect every exposed endpoint route and HTTP method.

### Why use RapidAPI Hub Scraper?

- **SaaS founders:** Discover which API categories are oversaturated and where underserved gaps exist before committing to a build.
- **Competitive researchers:** Track popularity scores and subscriber counts for any API vertical over time.
- **Product teams:** Monitor competitor APIs for pricing model changes and new endpoint additions.
- **Integration developers:** Audit which APIs meet your latency and reliability thresholds before subscribing.
- **Market analysts:** Build a structured dataset of the API economy for investment research or trend reporting.

### How to use RapidAPI Hub Scraper

1. Go to the RapidAPI Hub Scraper page on the Apify Store and click **Try for free**.
2. Leave Start URLs empty to scrape the global featured listing, or paste a specific RapidAPI category URL.
3. Set optional filters: category name, pricing model, minimum success rate, or maximum latency.
4. Set **Max Items** to control the number of results. Enable **Deep Scrape** to collect endpoint-level data.
5. Click **Start**. Results appear in the Output tab within seconds.
6. Download your data as JSON, CSV, Excel, or HTML.

### Input

| Field | Type | Required | Description |
|---|---|---|---|
| `startUrls` | array of URLs | No | RapidAPI Hub category or collection URLs to crawl. Leave empty to scrape the global featured listing. |
| `searchQueries` | array of strings | No | Keywords to filter API listings by. Matched against API name, title, description, and category. |
| `categories` | array of strings | No | Only return APIs in these categories, e.g. `Weather`, `Finance`, `Sports`. Leave empty for all. |
| `pricingFilter` | enum | No | Filter by pricing model. Options: Any, Free only, Freemium only, Paid only. Defaults to Any. |
| `minPopularityScore` | number | No | Only return APIs with a RapidAPI popularity score at or above this value (0 to 10). Defaults to 0. |
| `minSuccessRate` | number | No | Only return APIs with an average success rate at or above this percentage (0 to 100). Defaults to 0. |
| `maxLatency` | integer | No | Only return APIs with average latency at or below this value in milliseconds. Set to 0 for no limit. |
| `collectionsFilter` | array of strings | No | Filter to specific RapidAPI collection slugs, e.g. `weather-apis`, `sports-apis`. Leave empty for all. |
| `deepScrape` | boolean | No | Visit each API profile to collect all exposed endpoint routes, HTTP methods, names, and descriptions. Increases result rows significantly. |
| `maxItems` | integer | No | Maximum total API listings to extract. Set to 0 for no limit. Defaults to 100. |
| `proxyConfiguration` | object | No | Proxy settings. Datacenter proxies (the default) work for most requests. Switch to Residential only if hitting rate limits at very high volume. |

### Output

Each record is fully flat with no nested objects. Download as JSON, CSV, or Excel from the Output tab.

```json
{
  "api_id": "api_abc123",
  "name": "open-weather-map",
  "title": "Open Weather Map",
  "description": "Current and forecast weather data for any location worldwide.",
  "tags": "weather, forecast, climate",
  "version": "1.0",
  "category": "Weather",
  "base_url": "https://api.openweathermap.org",
  "playground_url": "https://rapidapi.com/community/api/open-weather-map",
  "developer": "community",
  "developer_name": "Community",
  "developer_type": "USER",
  "developer_id": 12345,
  "developer_username": "community",
  "developer_parent_id": "",
  "developer_parent_name": "",
  "developer_parent_username": "",
  "developer_parent_type": "",
  "developer_parent_thumbnail": "",
  "picture_url": "https://rapidapi.com/images/community.png",
  "popularity_score": 9.8,
  "latency_ms": 342,
  "service_level_percent": 100,
  "success_rate_percent": 99.2,
  "subscriptions_count": 1200000,
  "pricing_model": "FREEMIUM",
  "visibility": "PUBLIC",
  "created_at": "2018-03-15T10:00:00.000Z",
  "updated_at": "2024-11-01T09:00:00.000Z",
  "rapidapi_url": "https://rapidapi.com/community/api/open-weather-map",
  "endpoint_id": "",
  "endpoint_route": "",
  "endpoint_method": "",
  "endpoint_name": "",
  "endpoint_description": "",
  "endpoint_playground_url": "",
  "endpoint_params_count": 0,
  "endpoint_headers_count": 0,
  "scraped_at": "2026-06-23T17:00:00.000Z"
}
````

### Data table

| Field | Type | Description |
|---|---|---|
| `api_id` | string | Unique API identifier, prefixed with `api_`. |
| `name` | string | URL slug used in the RapidAPI marketplace. |
| `title` | string | Display name of the API. |
| `description` | string | Short description from the API listing. |
| `tags` | string | Comma-separated tags or keywords associated with the API. |
| `version` | string | Current published version string, if available. |
| `category` | string | Primary category on RapidAPI Hub. |
| `base_url` | string | Base URL for requests, if listed publicly. |
| `playground_url` | string | Direct link to the RapidAPI playground for this API. |
| `developer` | string | Developer username. |
| `developer_name` | string | Full display name of the developer. |
| `developer_type` | string | Account type of the developer. |
| `developer_id` | number | Numeric developer account ID. |
| `developer_username` | string | Developer username on RapidAPI. |
| `developer_parent_id` | string | Parent organization ID, if the developer belongs to an org. |
| `developer_parent_name` | string | Parent organization display name. |
| `developer_parent_username` | string | Parent organization username. |
| `developer_parent_type` | string | Parent organization account type. |
| `developer_parent_thumbnail` | string | URL to the parent organization thumbnail. |
| `picture_url` | string | URL to the API cover image or logo. |
| `popularity_score` | number | RapidAPI popularity score from 0 to 10. |
| `latency_ms` | number | Average response latency in milliseconds. |
| `service_level_percent` | number | Average service level percentage. |
| `success_rate_percent` | number | Average success rate percentage. |
| `subscriptions_count` | number | Number of active subscribers on RapidAPI. |
| `pricing_model` | string | Pricing model: `FREE`, `FREEMIUM`, or `PAID`. |
| `visibility` | string | Visibility setting: `PUBLIC` or `PRIVATE`. |
| `created_at` | string | ISO 8601 timestamp when the API was first listed. |
| `updated_at` | string | ISO 8601 timestamp of the most recent update. |
| `rapidapi_url` | string | Full marketplace listing URL. |
| `endpoint_id` | string | Endpoint identifier (deep scrape only). |
| `endpoint_route` | string | Endpoint route path, e.g. `/v1/current` (deep scrape only). |
| `endpoint_method` | string | HTTP method, e.g. `GET`, `POST` (deep scrape only). |
| `endpoint_name` | string | Display name of the endpoint (deep scrape only). |
| `endpoint_description` | string | Description of what the endpoint returns (deep scrape only). |
| `endpoint_playground_url` | string | Direct playground link for this endpoint (deep scrape only). |
| `endpoint_params_count` | number | Number of URL or query parameters (deep scrape only). |
| `endpoint_headers_count` | number | Number of required request headers (deep scrape only). |
| `scraped_at` | string | ISO 8601 timestamp of when this record was extracted. |

### Pricing

This Actor uses pay-per-event pricing. You are charged for each API listing successfully extracted and saved to the dataset.

You are not charged for listings filtered out by your search or quality criteria, or for requests that return no data.

### Tips or advanced options

- **Use category filters to narrow results:** Pass one or more names such as `Finance` or `Sports` to return only relevant listings.
- **Enable deep scrape for endpoint mapping:** Turn on Deep Scrape to collect every route and HTTP method exposed by each API. Useful for integration audits and API comparison tools.
- **Filter by success rate for reliable picks:** Set Min Success Rate to 95 or higher to surface only APIs with a strong reliability track record.
- **Stack filters for precision sourcing:** Combine category, pricing model, and latency filters to find free APIs under 500ms with high success rates in a single run.

### FAQ, disclaimers, and support

##### Is it legal to scrape RapidAPI Hub?

Yes. This tool accesses only publicly visible marketplace listing pages and does not bypass any login, paywall, or access control.

##### Does deep scrape cost more per run?

Deep scrape visits each API profile page to collect endpoint data. This increases the number of result rows. You are charged per endpoint row returned, not per API visited.

##### Can I scrape a specific category or collection?

Yes. Paste a RapidAPI category URL into Start URLs, or use the Category Filter and Collections fields to target specific verticals without providing a URL.

##### How do I get support or report a bug?

Open an issue on the [Actor's Issues tab](https://apify.com/getascraper/rapidapi-scraper/issues). For custom integrations, contact us through the Apify platform.

# Actor input Schema

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

RapidAPI Hub category or collection URLs to crawl. Leave empty to use the global featured listing.

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

Keywords to filter API listings by. Matches against API name, title, description, and category.

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

Only return APIs in these categories, e.g. Weather, Finance, Sports. Leave empty for all categories.

## `pricingFilter` (type: `string`):

Filter APIs by pricing model. Choose Any to return all pricing tiers.

## `minPopularityScore` (type: `number`):

Only return APIs with a RapidAPI popularity score at or above this value (0 to 10).

## `minSuccessRate` (type: `number`):

Only return APIs with an average success rate at or above this percentage (0 to 100).

## `maxLatency` (type: `integer`):

Only return APIs with average latency at or below this value in milliseconds. Set to 0 for no limit.

## `collectionsFilter` (type: `array`):

Filter to specific RapidAPI collection slugs, e.g. weather-apis, sports-apis. Leave empty for all collections.

## `deepScrape` (type: `boolean`):

Visit each API profile to collect all exposed endpoint routes, HTTP methods, names, and descriptions.

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

Maximum total API listings to extract. Set to 0 for no limit.

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

Datacenter proxies (the default) work for RapidAPI's server-rendered pages and are fast and cheap. Switch to Residential only if hitting rate limits at very high volume.

## Actor input object example

```json
{
  "startUrls": [],
  "searchQueries": [],
  "categories": [],
  "pricingFilter": "",
  "minPopularityScore": 0,
  "minSuccessRate": 0,
  "maxLatency": 0,
  "collectionsFilter": [],
  "deepScrape": false,
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (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 = {
    "startUrls": [],
    "searchQueries": [],
    "categories": [],
    "pricingFilter": "",
    "minPopularityScore": 0,
    "minSuccessRate": 0,
    "maxLatency": 0,
    "collectionsFilter": [],
    "deepScrape": false,
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("getascraper/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 = {
    "startUrls": [],
    "searchQueries": [],
    "categories": [],
    "pricingFilter": "",
    "minPopularityScore": 0,
    "minSuccessRate": 0,
    "maxLatency": 0,
    "collectionsFilter": [],
    "deepScrape": False,
    "maxItems": 100,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("getascraper/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 '{
  "startUrls": [],
  "searchQueries": [],
  "categories": [],
  "pricingFilter": "",
  "minPopularityScore": 0,
  "minSuccessRate": 0,
  "maxLatency": 0,
  "collectionsFilter": [],
  "deepScrape": false,
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call getascraper/rapidapi-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "RapidAPI Hub Scraper: API Listings, Metrics and Developer Data",
        "description": "Extract API marketplace listings from RapidAPI Hub. Get category, pricing model, success rate, latency, subscriptions, and full developer profile for thousands of public APIs. Filter by category, pricing model, or quality threshold.",
        "version": "0.1",
        "x-build-id": "3WML3hCKTJ1uoD9ns"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/getascraper~rapidapi-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-getascraper-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/getascraper~rapidapi-scraper/runs": {
            "post": {
                "operationId": "runs-sync-getascraper-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/getascraper~rapidapi-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-getascraper-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": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "RapidAPI Hub category or collection URLs to crawl. Leave empty to use the global featured listing.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchQueries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "Keywords to filter API listings by. Matches against API name, title, description, and category.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "categories": {
                        "title": "Category Filter",
                        "type": "array",
                        "description": "Only return APIs in these categories, e.g. Weather, Finance, Sports. Leave empty for all categories.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "pricingFilter": {
                        "title": "Pricing Model",
                        "enum": [
                            "",
                            "FREE",
                            "FREEMIUM",
                            "PAID"
                        ],
                        "type": "string",
                        "description": "Filter APIs by pricing model. Choose Any to return all pricing tiers.",
                        "default": ""
                    },
                    "minPopularityScore": {
                        "title": "Min Popularity Score",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "number",
                        "description": "Only return APIs with a RapidAPI popularity score at or above this value (0 to 10).",
                        "default": 0
                    },
                    "minSuccessRate": {
                        "title": "Min Success Rate (%)",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "number",
                        "description": "Only return APIs with an average success rate at or above this percentage (0 to 100).",
                        "default": 0
                    },
                    "maxLatency": {
                        "title": "Max Latency (ms)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return APIs with average latency at or below this value in milliseconds. Set to 0 for no limit.",
                        "default": 0
                    },
                    "collectionsFilter": {
                        "title": "Collections Filter",
                        "type": "array",
                        "description": "Filter to specific RapidAPI collection slugs, e.g. weather-apis, sports-apis. Leave empty for all collections.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "deepScrape": {
                        "title": "Deep Scrape (Endpoints)",
                        "type": "boolean",
                        "description": "Visit each API profile to collect all exposed endpoint routes, HTTP methods, names, and descriptions.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum total API listings to extract. Set to 0 for no limit.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Datacenter proxies (the default) work for RapidAPI's server-rendered pages and are fast and cheap. Switch to Residential only if hitting rate limits at very high volume.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
