# 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:** 7 total users, 6 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 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.
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 for marketplace API data

RapidAPI Scraper collects public API listings from [RapidAPI](https://rapidapi.com/) into an Apify dataset. Use this rapidapi scraper to search the marketplace by keyword, enrich exact API profile URLs, browse categories, or collect APIs from collection slugs such as `popular-apis` without opening each profile by hand.

- [Research RapidAPI marketplace APIs](https://apify.com/maximedupre/rapidapi-scraper/examples/rapidapi-marketplace-api-research) by keyword and export names, providers, categories, pricing labels, and quality metrics.
- [Compare RapidAPI pricing](https://apify.com/maximedupre/rapidapi-scraper/examples/rapidapi-pricing-research) across public API profiles, billing plans, subscriptions, and source-visible pricing labels.
- Build [free API for testing](https://apify.com/maximedupre/rapidapi-scraper/examples/free-api-for-testing-shortlist) shortlists by searching RapidAPI and reviewing public pricing, category, metric, and documentation fields.
- Create [developer API catalogs](https://apify.com/maximedupre/rapidapi-scraper/examples/rapidapi-profile-api-catalog) from RapidAPI profile URLs with provider details, website links, documentation, and endpoint metadata.
- Monitor [RapidAPI categories or collections](https://apify.com/maximedupre/rapidapi-scraper/examples/rapidapi-category-collection-monitoring) over time with scheduled Apify runs, exports, webhooks, or API workflows.

You do not need a RapidAPI account, API key, cookies, or browser session. For a quick first run, use the prefilled `Search keywords` section, keep `Detail level` on `Basic listing`, and lower `Maximum discovered APIs` when you want a smaller test.

#### 📦 Data you can extract

Each saved row is one successfully scraped RapidAPI listing or profile. Rows 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` 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.

#### 🚀 How to run it

1. Open the Actor input.
2. Fill exactly one target section.
3. Leave the other target sections empty.
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.

#### 🎯 Input options

Fill one target section per run. The filled section tells the Actor what kind of RapidAPI target to scrape, so leave the other target sections empty.

`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 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 collection 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.

#### 🧾 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"
	},
	"metrics": {
		"score": null,
		"popularityScore": 98.2,
		"latencyMs": 312,
		"serviceLevelPercent": 99.9,
		"successRatePercent": 99.1
	},
	"billingPlans": [],
	"billingItems": [],
	"rating": {
		"value": 4.7,
		"count": 128,
		"best": 5
	},
	"subscriptionsCount": 21834,
	"websiteUrl": "https://www.weatherapi.com/",
	"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.

No actor-start event is charged. Invalid targets, empty results, skipped duplicates, and source fields that RapidAPI does not expose are not saved as charged result rows.

#### 🔌 Integrations

https://www.youtube.com/watch?v=bNACk1\_S\_6w\&list=PLObrtcm1Kw6MUrlLNDbK9QRg8VDJg0gOW\&index=4

- Run the Actor through the Apify API and consume rows from the default dataset endpoint.
- Schedule repeat runs to monitor RapidAPI categories, collections, or keywords.
- Export results as JSON, CSV, Excel, XML, RSS, or HTML for analysis.
- Send completed runs to webhooks, databases, spreadsheets, dashboards, or internal API catalogs.

#### ❓ 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. Fill the `Profile URLs` section with one or more RapidAPI 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.

##### 💳 Can I use it for RapidAPI pricing research?

Yes. The output can include pricing labels, billing plans, billing items, subscription counts, and public profile facts when RapidAPI exposes them. The Actor does not test paid plans or call the listed APIs.

##### 🧪 Can it help find free API for testing options?

Yes, as a research step. Search RapidAPI keywords or collections, then review public pricing labels, billing plans, documentation, and endpoint metadata. The Actor does not verify that an API key works or that a provider's free tier is still available.

##### 📭 Why are some fields null or empty?

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 instead of guessing.

##### 🧭 Why should I run separate target sections?

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.

##### 🔎 Why not use the RapidAPI API?

Use the RapidAPI API when you need to call a provider's API endpoint. Use this Actor when you need marketplace research data such as API listings, profile metadata, pricing labels, documentation links, metrics, and endpoint catalog facts across many public RapidAPI profiles.

##### 🔁 What are RapidAPI alternatives?

For API discovery, users may also compare public API directories, vendor websites, GitHub projects, provider docs, or other API marketplaces. This Actor focuses only on public RapidAPI marketplace pages and does not merge data from other sources.

### 📝 Changelog

- 1.1: Improved the input form so each RapidAPI target has its own section. Fill one target section per run, with a tuned default run that produces useful marketplace rows for review.
- 1.0: Updated the output contract for RapidAPI marketplace profiles, with provider website data available as the top-level `websiteUrl` field and validated tiered pricing for saved API results.
- 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

- [ChatGPT Marketplace Scraper ↗](https://apify.com/maximedupre/chatgpt-marketplace-scraper) - Search ChatGPT marketplace listings and enrich public custom GPT profiles.
- [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.
- [Product Hunt Scraper ↗](https://apify.com/maximedupre/product-hunt-scraper) - Collect public startup launch data, rankings, reviews, and website enrichment.
- [Sitemap Sniffer ↗](https://apify.com/maximedupre/sitemap-sniffer) - Find sitemap files from domains, roots, robots.txt, and sitemap URLs with URL counts and inventory rows.

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

# Actor input Schema

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

Basic returns listing rows. Profile adds billing, docs, and provider facts. Endpoints adds public endpoint metadata.

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

RapidAPI marketplace queries to search. Fill this section only when you want keyword discovery.

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

RapidAPI profile or playground URLs to fetch directly. Fill this section only when you want exact profile data.

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

RapidAPI category names to browse. Fill this section only when you want category discovery.

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

RapidAPI collection slugs to browse. Fill this section only when you want collection discovery.

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

Source order for search, category, and collection targets.

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

Direction for source sorts that support ascending or descending order.

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

Maximum API rows to collect from search, category, or collection discovery.

## Actor input object example

```json
{
  "detailLevel": "basic",
  "searchTerms": [
    "weather",
    "translation"
  ],
  "sortBy": "ByRelevance",
  "order": "ASC",
  "maxResults": 500
}
```

# Actor output Schema

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

Open the dataset with one row for each successfully scraped RapidAPI 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"
    ]
};

// 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",
    ] }

# 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"
  ]
}' |
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": "1.1",
        "x-build-id": "NEtGstVREPKfPJIie"
    },
    "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",
                "properties": {
                    "detailLevel": {
                        "title": "Detail level",
                        "enum": [
                            "basic",
                            "profile",
                            "profileAndEndpoints"
                        ],
                        "type": "string",
                        "description": "Basic returns listing rows. Profile adds billing, docs, and provider facts. Endpoints adds public endpoint metadata.",
                        "default": "basic"
                    },
                    "searchTerms": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "RapidAPI marketplace queries to search. Fill this section only when you want keyword discovery.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "apiUrls": {
                        "title": "RapidAPI profile URLs",
                        "type": "array",
                        "description": "RapidAPI profile or playground URLs to fetch directly. Fill this section only when you want exact profile data.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categories": {
                        "title": "Categories",
                        "type": "array",
                        "description": "RapidAPI category names to browse. Fill this section only when you want category discovery.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "collections": {
                        "title": "Collections",
                        "type": "array",
                        "description": "RapidAPI collection slugs to browse. Fill this section only when you want collection discovery.",
                        "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 source sorts that support ascending or descending order.",
                        "default": "ASC"
                    },
                    "maxResults": {
                        "title": "Maximum discovered APIs",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum API rows to collect from search, category, or collection discovery.",
                        "default": 500
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
