# npm Registry Scraper - Search & Download Stats (`parseforge/npm-registry-scraper`) Actor

Search and scrape npm package data including versions, descriptions, authors, licenses, keywords, and weekly/total download counts from the public npm registry API.

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

## Pricing

from $19.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)

## 📦 npm Registry Scraper

> 🚀 **Export npm package data in seconds.** Search **3,000,000+ packages** by keyword, sort by popularity, quality, or maintenance, and get full metadata including versions, licenses, authors, keywords, and weekly/total download counts - no API key required.

> 🕒 **Last updated:** 2026-05-21 · **📊 14 fields** per record · **📦 3M+ packages** · **🌍 Public registry** · **📈 Download stats included**

The **npm Registry Scraper** exports package metadata directly from the public npm registry API and returns **14 fields per record**, including package name, version, description, author, license, homepage, repository, keywords, weekly downloads, total downloads, last published date, and the direct npm URL. The underlying data comes straight from the official npm registry maintained by GitHub and is updated in real time.

The registry covers **every published npm package**, from flagship frameworks like React, Vue, and Express to niche utilities. This Actor delivers the complete metadata profile plus download statistics with a single run. No auth, no scraping workarounds - the registry API is fully public.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Developers, data analysts, open-source researchers, security teams, marketing analysts, DevRel professionals | Package discovery, dependency audits, popularity benchmarking, license compliance, competitive research, ecosystem mapping |

---

### 📋 What the npm Registry Scraper does

Four data-collection workflows in a single run:

- 🔍 **Keyword search.** Find packages matching any search term - framework names, function types, author names, or topic keywords.
- 📈 **Popularity ranking.** Sort results by download count to surface the most widely used packages first.
- 🏆 **Quality ranking.** Rank by code quality signals including test coverage, linting, and documentation completeness.
- 🔧 **Maintenance ranking.** Surface actively maintained packages based on update frequency and issue responsiveness.

Each record includes the package name, latest version, description, publisher username, license type, homepage and repository links, keyword tags, weekly downloads, all-time total downloads, the last published timestamp, and the direct npmjs.com URL.

> 💡 **Why it matters:** the npm registry hosts over 3,000,000 packages and grows by hundreds every day. Manual browsing only surfaces trending content. This Actor lets you query any keyword, retrieve the full metadata profile for matching packages, and export the results to CSV, Excel, JSON, or XML in seconds - ideal for building package catalogs, auditing dependencies, or tracking ecosystem growth over time.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded package dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>search</code></td><td>string</td><td><code>"react"</code></td><td>Search term to find npm packages (e.g. "typescript", "express", "date-fns").</td></tr>
<tr><td><code>sortBy</code></td><td>string</td><td><code>"popularity"</code></td><td>Ranking method: <code>optimal</code>, <code>quality</code>, <code>popularity</code>, or <code>maintenance</code>.</td></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Number of packages to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
</tbody>
</table>

**Example: top 50 React-related packages by popularity.**

```json
{
    "maxItems": 50,
    "search": "react",
    "sortBy": "popularity"
}
````

**Example: best-maintained TypeScript utility libraries.**

```json
{
    "maxItems": 100,
    "search": "typescript utility",
    "sortBy": "maintenance"
}
```

> ⚠️ **Good to Know:** the npm search API returns results based on the official registry index. Very new packages (published in the last few minutes) may not appear immediately. Download stats come from the npm downloads API and reflect real install counts including CI and automated installs - not just human-initiated downloads.

***

### 📊 Output

Each package record contains **14 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 📦 `name` | string | `"react"` |
| 🏷 `version` | string | `"19.2.6"` |
| 📝 `description` | string | `"React is a JavaScript library for building user interfaces."` |
| 👤 `author` | string | `"react-bot"` |
| 📜 `license` | string | `"MIT"` |
| 🌐 `homepage` | string | `"https://react.dev/"` |
| 🗄 `repository` | string | `"git+https://github.com/facebook/react.git"` |
| 🏷 `keywords` | array | `["react"]` |
| 📊 `weeklyDownloads` | integer | `134135283` |
| 📈 `totalDownloads` | integer | `4230521121` |
| 📅 `lastPublished` | string (ISO 8601) | `"2026-05-06T16:16:47.653Z"` |
| 🔗 `url` | string | `"https://www.npmjs.com/package/react"` |
| 🕒 `scrapedAt` | string (ISO 8601) | `"2026-05-21T22:56:54.151Z"` |
| ❌ `error` | string | null | `null` |

#### 📋 Sample Records

**Record 1 - react**

```json
{
  "name": "react",
  "version": "19.2.6",
  "description": "React is a JavaScript library for building user interfaces.",
  "author": "react-bot",
  "license": "MIT",
  "homepage": "https://react.dev/",
  "repository": "git+https://github.com/facebook/react.git",
  "keywords": ["react"],
  "weeklyDownloads": 134135283,
  "totalDownloads": 4230521121,
  "lastPublished": "2026-05-06T16:16:47.653Z",
  "url": "https://www.npmjs.com/package/react",
  "scrapedAt": "2026-05-21T22:56:54.151Z"
}
```

**Record 2 - react-router**

```json
{
  "name": "react-router",
  "version": "7.15.1",
  "description": "Declarative routing for React",
  "author": "GitHub Actions",
  "license": "MIT",
  "homepage": "https://github.com/remix-run/react-router#readme",
  "repository": "git+https://github.com/remix-run/react-router.git",
  "keywords": ["react", "router", "route", "routing", "history", "link"],
  "weeklyDownloads": 50265371,
  "totalDownloads": 1661085982,
  "lastPublished": "2026-05-14T14:40:53.242Z",
  "url": "https://www.npmjs.com/package/react-router",
  "scrapedAt": "2026-05-21T22:56:54.151Z"
}
```

***

### ✨ Why choose this Actor

| Feature | Benefit |
|---|---|
| 📡 Direct registry API | Data straight from npm - no intermediaries, no stale cache |
| 📊 Download statistics | Weekly and all-time totals in every record |
| 🔀 Multiple sort modes | popularity, quality, maintenance, or optimal ranking |
| 🏷 License field | Every record includes the SPDX license identifier |
| 📦 Keywords array | Full tag list for downstream filtering and categorization |
| ⚡ Fast execution | Typical 100-item run completes in under 10 seconds |
| 🌐 No auth required | Zero credentials - the npm registry is fully public |
| 💾 Multi-format export | CSV, Excel, JSON, XML out of the box |

***

### 📈 How it compares to alternatives

| Method | npm Registry Scraper | Manual browsing | npm CLI (`npm search`) | Custom script |
|---|---|---|---|---|
| Export to CSV/Excel | ✅ | ❌ | ❌ | Requires work |
| Download statistics | ✅ | ❌ partial | ❌ | Multiple API calls |
| Pagination support | ✅ up to 1M | ❌ | ❌ limited | Requires work |
| Runs in the cloud | ✅ | N/A | N/A | ❌ |
| Multiple sort modes | ✅ | ❌ | ❌ limited | Requires work |
| No setup required | ✅ | ✅ | Requires Node.js | Requires Node.js |

***

### 🚀 How to use

1. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) on Apify (no credit card required for the trial).
2. Open the **npm Registry Scraper** on the Apify Store.
3. Enter your search term and select a sort mode.
4. Set `maxItems` to the number of packages you need.
5. Click **Run** - results appear in the Dataset tab within seconds.
6. Click **Export** to download as CSV, Excel, JSON, or XML.

***

### 💼 Business use cases

#### 🔐 Security and license compliance

Audit dependencies across a stack. Search for packages used in your projects and extract license fields in bulk. Flag packages with non-permissive licenses (GPL, AGPL) before they reach production. Combine with total download counts to prioritize which packages to review first.

#### 📊 Competitive and market intelligence

Track the most popular packages in a given category (e.g. "date manipulation", "HTTP client", "state management"). Monitor weekly download trends to identify rising challengers or declining incumbents. Export to Excel and build charts showing ecosystem momentum.

#### 🛠 Developer tooling and cataloging

Build internal package catalogs for engineering teams. Index packages by keyword, license, and author to power internal search tools. Use the repository field to cross-reference with GitHub metrics for combined scoring.

#### 🎓 Research and education

Map the growth of JavaScript ecosystems over time. Identify the most downloaded packages per category for curriculum design. Analyze keyword co-occurrence patterns across package descriptions to understand how developers categorize their work.

***

### 🔌 Automating npm Registry Scraper

Connect this Actor to your existing tools with no code required:

- **Make (Integromat):** Trigger a run on a schedule, then push results to Google Sheets, Airtable, or a database.
- **Zapier:** Start a run when a GitHub issue is created (e.g. "evaluate package X"), then post results to Slack.
- **Slack:** Receive a formatted weekly digest of the most downloaded packages in your tech stack.
- **Google Sheets:** Append new packages to a tracking spreadsheet automatically each week.
- **Webhooks:** Fire a POST to your own endpoint when a run completes, with the dataset URL in the payload.

***

### 🌟 Beyond business use cases

#### 🔬 Open-source research

Measure the growth rate of package categories over time. Which testing frameworks are gaining ground? Which bundlers are losing traction? Weekly download deltas tell the story quantitatively.

#### 🗺 Ecosystem mapping

Cross-reference npm keywords with GitHub topics and Stack Overflow tags to build a unified map of JavaScript sub-ecosystems. Identify gaps where popular problem domains lack well-maintained open-source solutions.

#### 🎨 Creative exploration

Generate word clouds from keyword arrays across thousands of packages. Visualize the language developers use to describe their work - from "utility" and "parser" to "animation" and "cli".

#### 🤝 Non-profit and education

Build curated package lists for coding bootcamps or open curricula. Identify accessible, well-documented libraries appropriate for learners at different skill levels, using quality scores and weekly downloads as proxies.

***

### 🤖 Ask an AI assistant about this scraper

Not sure which search terms to use? Paste a sample record into ChatGPT or Claude and ask:

- "Which of these packages would best fit a Next.js project?"
- "Flag any packages with non-permissive licenses."
- "Which packages have declining downloads and may be deprecated?"
- "Group these packages by their primary use case."

The 14-field output gives AI assistants enough context to reason about packages, licenses, and ecosystem positioning without any additional lookup.

***

### ❓ Frequently Asked Questions

**📦 Where does the data come from?**
Directly from the official npm registry API at `registry.npmjs.org` and download stats from `api.npmjs.org`. No scraping, no third-party intermediaries.

**🔑 Do I need an API key?**
No. The npm registry is fully public and requires no authentication.

**📊 What does "weeklyDownloads" count?**
The number of times the package tarball was downloaded from the npm CDN in the last 7 days. This includes CI/CD pipelines, automated installs, and human-initiated `npm install` commands.

**📈 What does "totalDownloads" count?**
All downloads since approximately 2010 (when npm started recording stats) through the current date. The exact range is `2010-01-01` to `2099-12-31` as reported by the npm downloads API.

**🔀 What is the difference between sort modes?**
`popularity` ranks by raw download volume. `quality` uses signals like test coverage and documentation. `maintenance` considers commit frequency and issue close rate. `optimal` is npm's blended default that combines all three.

**📦 How many packages can I get per search?**
Up to 1,000,000 on a paid plan. The scraper paginates through the registry API automatically. Free plan is capped at 10 packages per run.

**🔍 What happens if my search term returns no results?**
The Actor logs a warning and exits cleanly with zero records. No error is pushed to the dataset.

**🏷 What is in the keywords field?**
An array of tags the package author added in `package.json`. Some packages have no keywords and the field will be `null`.

**🕒 How fresh is the data?**
The npm registry API is updated in real time. Every run fetches live data - there is no caching on our end.

**💰 Is there a free tier?**
Yes. Free users get 10 packages per run. [Upgrade to a paid plan](https://console.apify.com/sign-up?fpr=vmoqkp) to unlock up to 1,000,000 packages per run.

***

### 🔌 Integrate with any app

This Actor connects natively to every tool in the Apify ecosystem:

| Integration | How |
|---|---|
| Google Sheets | Use the Apify Google Sheets integration to write rows automatically |
| Airtable | Push JSON records to a base via the Apify Airtable integration |
| Make (Integromat) | Trigger runs and route results with the Apify Make module |
| Zapier | Start runs and parse datasets with the Apify Zapier app |
| Slack | Post dataset summaries to channels via webhook |
| REST API | `GET /v2/datasets/{id}/items` for direct programmatic access |
| Python / Node.js | Use the official Apify client SDK to run and read results |
| Webhooks | Configure a POST callback on run completion |

***

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [parseforge/producthunt-scraper](https://apify.com/parseforge/producthunt-scraper) | Scrape Product Hunt launches, upvotes, makers, and comments |
| [parseforge/upwork-scraper](https://apify.com/parseforge/upwork-scraper) | Extract Upwork job listings with skills, budget, and client data |
| [parseforge/remoteok-scraper](https://apify.com/parseforge/remoteok-scraper) | Collect remote job postings with tech stack and salary ranges |
| [parseforge/openfda-scraper](https://apify.com/parseforge/openfda-scraper) | Access FDA drug, device, and food safety event data |
| [parseforge/wipo-brand-database-scraper](https://apify.com/parseforge/wipo-brand-database-scraper) | Search international trademark registrations from WIPO |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for 50+ production-ready data scrapers covering developer tools, job boards, public registries, and more.

***

*This Actor uses the public npm registry API. All data is sourced from npmjs.com and api.npmjs.org. ParseForge is not affiliated with npm, Inc. or GitHub. Use responsibly and in accordance with npm's terms of service.*

# Actor input Schema

## `search` (type: `string`):

Search term to find npm packages (e.g. 'react', 'typescript', 'express').

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

Ranking method for search results.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000.

## Actor input object example

```json
{
  "search": "react",
  "sortBy": "popularity",
  "maxItems": 10
}
```

# 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 = {
    "search": "react",
    "sortBy": "popularity",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/npm-registry-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 = {
    "search": "react",
    "sortBy": "popularity",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/npm-registry-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 '{
  "search": "react",
  "sortBy": "popularity",
  "maxItems": 10
}' |
apify call parseforge/npm-registry-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "npm Registry Scraper - Search & Download Stats",
        "description": "Search and scrape npm package data including versions, descriptions, authors, licenses, keywords, and weekly/total download counts from the public npm registry API.",
        "version": "0.1",
        "x-build-id": "oLzaDQ6QmPkGRQQiX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~npm-registry-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-npm-registry-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~npm-registry-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-npm-registry-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~npm-registry-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-npm-registry-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "search"
                ],
                "properties": {
                    "search": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search term to find npm packages (e.g. 'react', 'typescript', 'express')."
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "optimal",
                            "quality",
                            "popularity",
                            "maintenance"
                        ],
                        "type": "string",
                        "description": "Ranking method for search results."
                    },
                    "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."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
