# Libraries.io Package Scraper (`parseforge/libraries-io-scraper`) Actor

Gather open source package data from Libraries.io across npm, PyPI, Maven, Cargo, and dozens more registries. Every record carries the name, platform, SourceRank, stars, dependents count, latest release, license, and keywords. Handy for dependency research and supply chain audits.

- **URL**: https://apify.com/parseforge/libraries-io-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $9.00 / 1,000 results

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 📦 Libraries.io Package Scraper

> 🚀 **Pull package intelligence across 31 registries.** Search a keyword or list exact packages and get SourceRank, stars, dependents, and license data for each one.

> 🕒 **Last updated:** 2026-06-02 · **📊 26 fields** per package · npm, PyPI, Maven, Cargo, and 27 more · keyword or package input

Collect open source package metadata from Libraries.io, the cross-ecosystem index of 31 package managers. Search by keyword or pass exact packages, and for every project get its SourceRank, stars, forks, dependents count, latest release, license, keywords, and repository link.

**Coverage:** npm, PyPI, Maven, Go, NuGet, Packagist, Cargo, RubyGems, CocoaPods, Hex, Conda, CRAN, CPAN, and more. Search across all of them or filter to one.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Developers and tech leads | Compare libraries before adopting |
| Security and compliance teams | Audit dependencies and licenses |
| Investors and analysts | Track ecosystem momentum |
| Researchers | Study open source trends |

### 📋 What the Libraries.io Package Scraper does

- Searches packages by keyword across every supported registry.
- Looks up exact packages by "platform/name" with no key needed.
- Returns 26 structured fields per package, including SourceRank.
- Captures stars, forks, dependents, and dependent repos.
- Flags deprecated packages with a status and reason.
- Exports to CSV, Excel, JSON, XML, or via API.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `searchTerms` | array | Keywords to search across registries. |
| `packages` | array | Exact packages as "platform/name" (no key needed). |
| `platform` | string | Optional. Restrict keyword search to one registry. |
| `sort` | string | Order search results (SourceRank, stars, dependents, and more). |
| `maxItems` | integer | Cap on packages returned. Free plan is limited to 10. |
| `apiKey` | string | Libraries.io API key for keyword search. A shared key ships by default. |

**Example 1: keyword search**
```json
{
  "searchTerms": ["http client"],
  "sort": "rank",
  "maxItems": 50
}
````

**Example 2: exact packages**

```json
{
  "searchTerms": [],
  "packages": ["npm/react", "pypi/django", "cargo/serde"]
}
```

> ⚠️ **Good to Know:** keyword search uses the Libraries.io API and a shared key ships by default. Exact package lookups work without any key. The `status` and `deprecationReason` fields fill in only for deprecated or removed packages.

### 📊 Output

Each record contains the following fields:

| Field | Description |
|---|---|
| 📦 `name` | Package name |
| 🧰 `platform` | Package manager |
| 🔗 `projectUrl` | Libraries.io page |
| 📊 `rank` | SourceRank score |
| 📝 `description` | Package description |
| 💬 `language` | Primary language |
| 🏠 `homepage` | Homepage URL |
| 🐙 `repositoryUrl` | Source repository |
| ⭐ `stars` | Repository stars |
| 🍴 `forks` | Repository forks |
| 🔗 `dependentsCount` | Packages depending on it |
| 🗂 `dependentReposCount` | Repos depending on it |
| 🏷 `latestReleaseNumber` | Latest release |
| 📅 `latestReleasePublishedAt` | Latest release date |
| ✅ `latestStableReleaseNumber` | Latest stable release |
| 📜 `licenses` | License |
| 📜 `normalizedLicenses` | Normalized license list |
| 🔑 `keywords` | Package keywords |
| 🚦 `status` | Deprecated or removed status |
| ⚠️ `deprecationReason` | Reason if deprecated |
| 🔢 `versionsCount` | Number of published versions |
| 👥 `contributionsCount` | Contributions count |
| 🔗 `packageManagerUrl` | Registry page |
| 🔎 `searchTerm` | Query that surfaced this package |
| 🕒 `scrapedAt` | Collection timestamp |
| ❌ `error` | Error message, null on success |

**Real sample records:**

```json
{
  "name": "serde",
  "platform": "Cargo",
  "projectUrl": "https://libraries.io/Cargo/serde",
  "rank": 29,
  "description": "A generic serialization/deserialization framework",
  "language": "Rust",
  "repositoryUrl": "https://github.com/serde-rs/serde",
  "stars": 10504,
  "forks": 893,
  "dependentsCount": 60384,
  "latestReleaseNumber": "1.0.228",
  "licenses": "MIT OR Apache-2.0",
  "keywords": ["serde", "serialization", "derive", "no-std", "rust"],
  "versionsCount": 315,
  "error": null
}
```

```json
{
  "name": "axios",
  "platform": "NPM",
  "projectUrl": "https://libraries.io/NPM/axios",
  "rank": 32,
  "description": "Promise based HTTP client for the browser and node.js",
  "language": "JavaScript",
  "repositoryUrl": "https://github.com/axios/axios",
  "stars": 109086,
  "forks": 11717,
  "dependentsCount": 255309,
  "latestReleaseNumber": "1.16.1",
  "licenses": "MIT",
  "keywords": ["http", "ajax", "promise", "fetch", "rest", "api", "client"],
  "versionsCount": 140,
  "error": null
}
```

```json
{
  "name": "reqwest",
  "platform": "Cargo",
  "projectUrl": "https://libraries.io/Cargo/reqwest",
  "rank": 27,
  "description": "higher level HTTP client library",
  "language": "Rust",
  "repositoryUrl": "https://github.com/seanmonstar/reqwest",
  "stars": 11606,
  "forks": 1369,
  "dependentsCount": 19735,
  "latestReleaseNumber": "0.13.2",
  "licenses": "MIT OR Apache-2.0",
  "keywords": ["client", "http", "request", "rust"],
  "versionsCount": 123,
  "error": null
}
```

### ✨ Why choose this Actor

- **Cross-ecosystem.** One run spans npm, PyPI, Cargo, Maven, and 27 more.
- **SourceRank built in.** Compare library health on a single score.
- **Dependency reach.** Dependents and dependent repos on every package.
- **No key for lookups.** Exact package lookups need no API key at all.
- **Ready to export.** CSV, Excel, JSON, XML, or API, with a clean table view.

### 📈 How it compares to alternatives

| | Libraries.io Package Scraper | Manual API calls | Generic web scrapers |
|---|---|---|---|
| 31 registries in one run | ✅ | ⚠️ | ❌ |
| SourceRank and dependents | ✅ | ⚠️ | ❌ |
| Keyword and exact lookup | ✅ | ⚠️ | ⚠️ |
| Deprecation flags | ✅ | ⚠️ | ❌ |
| Export to CSV/Excel/JSON/XML | ✅ | ❌ | ⚠️ |

### 🚀 How to use

1. Create a free Apify account using [this sign-up link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the Libraries.io Package Scraper.
3. Enter `searchTerms` or `packages`, optionally pick a `platform`, and set `maxItems`.
4. Click **Start** and watch the dataset fill in real time.
5. Export your results as CSV, Excel, JSON, or XML, or pull them via API.

### 💼 Business use cases

**🔍 Library evaluation**
| Goal | How |
|---|---|
| Compare options | Search a keyword and sort by SourceRank |
| Check momentum | Look at stars and dependents |

**🛡 Dependency and license audit**
| Goal | How |
|---|---|
| Review licenses | List your packages and read the license fields |
| Spot deprecations | Watch the status and reason fields |

**📊 Ecosystem research**
| Goal | How |
|---|---|
| Map a niche | Aggregate packages across registries |
| Track leaders | Sort by dependents count |

**💡 Tech scouting**
| Goal | How |
|---|---|
| Find tools | Search by domain keyword |
| Benchmark | Compare rank across platforms |

### 🔌 Automating Libraries.io Package Scraper

Connect this Actor to your stack with Apify integrations: **Make**, **Zapier**, **Slack**, **Airbyte**, **GitHub**, and **Google Drive**. Schedule runs and push fresh package data into spreadsheets, databases, or alerts.

### 🌟 Beyond business use cases

- **Research:** study open source growth across ecosystems.
- **Personal:** vet libraries before adding them to a project.
- **Non-profit:** audit dependencies for community software.
- **Experimentation:** build software supply chain datasets.

### 🤖 Ask an AI assistant

Paste your dataset into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Copilot](https://copilot.microsoft.com) and ask for the most depended-on libraries, license breakdowns, or deprecated packages.

### ❓ Frequently Asked Questions

**1. Do I need an API key?**
Keyword search uses the Libraries.io API and a shared key ships by default. Exact package lookups work with no key.

**2. Which registries are covered?**
31 package managers, including npm, PyPI, Maven, Go, NuGet, Packagist, Cargo, RubyGems, and more.

**3. How do I look up an exact package?**
Add it to `packages` as "platform/name", for example "npm/react".

**4. What is SourceRank?**
A Libraries.io score that estimates package quality and popularity.

**5. Can I sort search results?**
Yes, by SourceRank, stars, dependents, dependent repos, latest release, or contributions.

**6. Does it flag deprecated packages?**
Yes. The status and deprecationReason fields fill in for deprecated or removed packages.

**7. What export formats are supported?**
CSV, Excel, JSON, XML, and API.

**8. Can I restrict search to one registry?**
Yes. Set the `platform` filter.

**9. Can I run it on a schedule?**
Yes, with Apify Schedules and integrations.

**10. Is there a free option?**
Yes. Free runs are limited to 10 items as a preview. Paid plans unlock up to 1,000,000.

### 🔌 Integrate with any app

Use the Apify API, webhooks, and 5,000-plus integrations to push Libraries.io data into Make, Zapier, Google Sheets, Airtable, databases, and more.

### 🔗 Recommended Actors

- [npm Registry Scraper](https://apify.com/parseforge/npm-registry-scraper)
- [PyPI Packages Scraper](https://apify.com/parseforge/pypi-packages-scraper)
- [crates.io Rust Scraper](https://apify.com/parseforge/crates-io-rust-scraper)
- [GitHub Trending Scraper](https://apify.com/parseforge/github-trending-scraper)
- [Packagist PHP Packages Scraper](https://apify.com/parseforge/packagist-php-packages-scraper)

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with Libraries.io. Data is provided by the Libraries.io open data platform.

# Actor input Schema

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

Keywords to search across package managers (e.g. "http client", "orm"). One result set per term.

## `packages` (type: `array`):

Exact packages as "platform/name" (e.g. "npm/react", "pypi/django", "cargo/serde").

## `platform` (type: `string`):

Restrict keyword search to one package manager.

## `sort` (type: `string`):

Order keyword search results.

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

Free users: limited to 10 items (preview). Paid users: optional, max 1,000,000.

## `apiKey` (type: `string`):

Libraries.io API key (needed for keyword search). A shared key is provided by default. Get your own free key at libraries.io/account.

## Actor input object example

```json
{
  "searchTerms": [
    "http client"
  ],
  "platform": "",
  "sort": "rank",
  "maxItems": 10,
  "apiKey": "5872e2c0b36eb1bac0d8788d7aee7f8b"
}
```

# 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 = {
    "searchTerms": [
        "http client"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/libraries-io-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": ["http client"],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/libraries-io-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": [
    "http client"
  ],
  "maxItems": 10
}' |
apify call parseforge/libraries-io-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Libraries.io Package Scraper",
        "description": "Gather open source package data from Libraries.io across npm, PyPI, Maven, Cargo, and dozens more registries. Every record carries the name, platform, SourceRank, stars, dependents count, latest release, license, and keywords. Handy for dependency research and supply chain audits.",
        "version": "0.1",
        "x-build-id": "5EC7YkCiYeHf4V373"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~libraries-io-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-libraries-io-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/parseforge~libraries-io-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-libraries-io-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/parseforge~libraries-io-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-libraries-io-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchTerms": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "Keywords to search across package managers (e.g. \"http client\", \"orm\"). One result set per term.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "packages": {
                        "title": "Specific packages",
                        "type": "array",
                        "description": "Exact packages as \"platform/name\" (e.g. \"npm/react\", \"pypi/django\", \"cargo/serde\").",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform filter (search)",
                        "enum": [
                            "",
                            "NPM",
                            "Pypi",
                            "Maven",
                            "Go",
                            "NuGet",
                            "Packagist",
                            "Cargo",
                            "Rubygems",
                            "CocoaPods",
                            "Pub",
                            "Hex",
                            "Conda",
                            "CRAN",
                            "CPAN",
                            "Clojars",
                            "SwiftPM",
                            "Elm",
                            "Julia"
                        ],
                        "type": "string",
                        "description": "Restrict keyword search to one package manager.",
                        "default": ""
                    },
                    "sort": {
                        "title": "Sort by (search)",
                        "enum": [
                            "rank",
                            "stars",
                            "dependents_count",
                            "dependent_repos_count",
                            "latest_release_published_at",
                            "contributions_count"
                        ],
                        "type": "string",
                        "description": "Order keyword search results.",
                        "default": "rank"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: limited to 10 items (preview). Paid users: optional, max 1,000,000."
                    },
                    "apiKey": {
                        "title": "Libraries.io API key",
                        "type": "string",
                        "description": "Libraries.io API key (needed for keyword search). A shared key is provided by default. Get your own free key at libraries.io/account.",
                        "default": "5872e2c0b36eb1bac0d8788d7aee7f8b"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
