# NPM Package Intelligence Scraper (`automation-lab/npm-package-intelligence-scraper`) Actor

Search npm packages and enrich them with registry metadata, downloads, maintainers, dependencies, links, and scoring signals.

- **URL**: https://apify.com/automation-lab/npm-package-intelligence-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## NPM Package Intelligence Scraper

Find and enrich npm packages from public registry APIs.

### What does NPM Package Intelligence Scraper do?

NPM Package Intelligence Scraper searches the public npm Registry and turns package discovery results into clean dataset rows.
It can also enrich exact package names such as `react`, `typescript`, or `@types/node`.
The actor is designed for software teams that need repeatable npm package research without building and maintaining registry API glue code.

### Who is it for?

- 🧑‍💻 Developers comparing package choices for a new project.
- 🔐 Supply-chain teams mapping maintainers, licenses, and dependency volume.
- 📈 DevRel teams tracking ecosystems around keywords and frameworks.
- 🧪 Product researchers building package intelligence spreadsheets.
- 🤖 Automation builders that need npm data inside no-code workflows.

### Why use this actor?

The npm Registry exposes useful public JSON, but teams still need pagination, enrichment, normalization, and exports.
This actor handles those details and stores the output in an Apify dataset ready for CSV, JSON, Excel, API, webhooks, or MCP tools.

### Key features

- 🔎 Search npm packages by one or more keywords.
- 📦 Enrich exact package names.
- 📊 Include weekly, monthly, and selected-period download counts.
- 🧾 Extract license, links, publisher, maintainers, and keywords.
- 🧮 Add dependency counts, version counts, scores, and TypeScript typings signal.
- ⚡ HTTP-only implementation; no browser or login required.

### Data table

| Field | Description |
| --- | --- |
| `packageName` | npm package name |
| `version` | current version from search or latest tag |
| `description` | package description |
| `weeklyDownloads` | weekly downloads from npm search |
| `monthlyDownloads` | monthly downloads from npm search |
| `downloadsInPeriod` | downloads for selected npm downloads period |
| `dependents` | npm search dependent count |
| `license` | package license |
| `repositoryUrl` | repository link when available |
| `maintainers` | package maintainers |

### How much does it cost to scrape npm package intelligence?

This actor uses pay-per-event pricing.
There is a small start charge and a per-package charge for each saved dataset item.
Use `maxItems` and `maxResultsPerQuery` to control run size.
For quick tests, keep the default prefill or reduce the limits.

### How to use it

1. Add search terms to `queries`, exact packages to `packageNames`, or both.
2. Choose `mode` if you only want search or only exact package enrichment.
3. Set `maxResultsPerQuery` and `maxItems`.
4. Keep metadata enrichment enabled; turn on downloads enrichment only when you need selected-period download counts.
5. Run the actor and export the dataset.

### Input options

#### `queries`

Keyword searches passed to the npm Registry search endpoint.
Examples:

- `react ui`
- `typescript cli`
- `pdf parser`

#### `packageNames`

Exact package names to enrich.
Scoped packages are supported.
Examples:

- `react`
- `typescript`
- `@types/node`

#### `mode`

Choose `search`, `packages`, or `both`.
When both queries and package names are provided, `both` is the best default.

#### `maxResultsPerQuery`

Maximum results requested for each search query.
The actor paginates the npm search API when needed.

#### `maxItems`

Total cap across all inputs.
This protects your budget when you provide many queries.

#### `enrichMetadata`

Fetches detailed package documents from `registry.npmjs.org/<package>`.
Disable it only when you need a faster, search-only export.

#### `enrichDownloads`

Fetches selected-period downloads from the npm downloads API.
This is useful for trend analysis and ranking, but it is optional because the npm downloads API can rate-limit large batches.

#### `downloadsPeriod`

Choose `last-day`, `last-week`, or `last-month`.

### Output example

```json
{
  "packageName": "react",
  "source": "search",
  "searchQuery": "react ui",
  "version": "19.2.7",
  "description": "React is a JavaScript library for building user interfaces.",
  "license": "MIT",
  "weeklyDownloads": 150302852,
  "monthlyDownloads": 583605358,
  "downloadsInPeriod": 583605358,
  "dependents": 212669,
  "repositoryUrl": "https://github.com/facebook/react",
  "versionsCount": 2500,
  "dependencyCount": 0,
  "hasTypes": false,
  "scrapedAt": "2026-06-24T00:00:00.000Z"
}
````

### Common workflows

#### Package selection research

Search a category such as `markdown parser`, sort by downloads and maintenance score, then shortlist packages with active repositories and suitable licenses.

#### Supply-chain review

Enrich a list of packages from `package.json` and export maintainers, licenses, dependency counts, repositories, and publish dates.

#### DevRel ecosystem tracking

Run recurring searches for framework or tooling terms and compare output over time.

#### Competitive intelligence

Track packages around a product category, such as `auth`, `observability`, or `vector database`.

### Integrations

- Send dataset rows to Google Sheets using Apify integrations.
- Trigger Slack or email notifications when scheduled runs finish.
- Use the Apify API from CI pipelines to enrich package lists.
- Connect output datasets to data warehouses.
- Use MCP from Claude or other tools for interactive package research.

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/npm-package-intelligence-scraper').call({
  queries: ['typescript cli'],
  packageNames: ['typescript', '@types/node'],
  mode: 'both',
  maxItems: 100
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/npm-package-intelligence-scraper').call(run_input={
    'queries': ['react ui'],
    'maxItems': 100,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~npm-package-intelligence-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"queries":["pdf parser"],"maxItems":100}'
```

### MCP usage

Use Apify MCP with this actor enabled:

`https://mcp.apify.com/?tools=automation-lab/npm-package-intelligence-scraper`

Claude Code setup:

```bash
claude mcp add apify-npm-package-intelligence https://mcp.apify.com/?tools=automation-lab/npm-package-intelligence-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-npm-package-intelligence": {
      "url": "https://mcp.apify.com/?tools=automation-lab/npm-package-intelligence-scraper"
    }
  }
}
```

Example prompts:

- "Find popular npm packages for markdown parsing and compare licenses."
- "Enrich these package names and return repository links and maintainers."
- "Search npm for TypeScript CLIs and rank by downloads."

### Tips for best results

- Use specific queries instead of very broad one-word searches.
- Combine keyword search with exact package names for complete reports.
- Keep `maxItems` modest for exploratory runs.
- Enable metadata enrichment for license and dependency fields.
- Enable downloads enrichment for small, focused batches when selected-period counts are required.
- Use `last-week` downloads for faster-moving trend snapshots.

### Troubleshooting

#### Why did I get fewer results than requested?

The actor de-duplicates package names across queries and exact package lists.
If several queries return the same popular packages, fewer unique rows may be saved.

#### Why are some fields empty?

Not every npm package declares homepage, repository, bugs, keywords, or TypeScript metadata.
The actor leaves unavailable values empty instead of guessing.

#### Does this need an npm token?

No.
The actor uses public npm Registry and downloads endpoints.

### Legality and ethical use

This actor collects publicly available package metadata from npm public APIs.
Use the data responsibly, respect npm service availability, and avoid excessive run sizes or unnecessary repetition.

### Related scrapers

- https://apify.com/automation-lab/npm-vulnerability-checker
- https://apify.com/automation-lab/website-contact-finder
- https://apify.com/automation-lab/github-repository-scraper

### FAQ

#### Can I scrape scoped packages?

Yes.
Use names such as `@types/node` in `packageNames`.

#### Can I schedule monitoring?

Yes.
Create an Apify task with your input and schedule it daily, weekly, or monthly.

#### Can I export CSV?

Yes.
Open the dataset and choose CSV, JSON, Excel, or API export.

#### Can I use this in automation?

Yes.
Use Apify webhooks, integrations, API clients, or MCP.

### Changelog

- Initial version: npm search, package metadata, downloads enrichment, and normalized package intelligence dataset.

# Actor input Schema

## `queries` (type: `array`):

Keywords to search on the public npm Registry, such as react ui, typescript cli, or pdf parser.

## `packageNames` (type: `array`):

Optional exact npm package names to enrich, including scoped packages like @types/node.

## `mode` (type: `string`):

Use keyword search, exact package enrichment, or both sources.

## `maxResultsPerQuery` (type: `integer`):

How many search results to collect for each query. Keep the prefill small for cheap test runs.

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

Hard cap across search and exact package inputs.

## `enrichMetadata` (type: `boolean`):

Fetch registry package documents for versions, dependencies, links, license, and maintainers.

## `enrichDownloads` (type: `boolean`):

Fetch npm downloads API counts for each package and selected period.

## `downloadsPeriod` (type: `string`):

Period used by the npm downloads API when enrichment is enabled.

## Actor input object example

```json
{
  "queries": [
    "react ui",
    "typescript cli"
  ],
  "packageNames": [
    "react",
    "@types/node",
    "typescript"
  ],
  "mode": "both",
  "maxResultsPerQuery": 20,
  "maxItems": 20,
  "enrichMetadata": true,
  "enrichDownloads": false,
  "downloadsPeriod": "last-month"
}
```

# Actor output Schema

## `overview` (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 = {
    "queries": [
        "react ui",
        "typescript cli"
    ],
    "packageNames": [
        "react",
        "@types/node",
        "typescript"
    ],
    "mode": "both",
    "maxResultsPerQuery": 20,
    "maxItems": 20,
    "enrichMetadata": true,
    "enrichDownloads": false,
    "downloadsPeriod": "last-month"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/npm-package-intelligence-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 = {
    "queries": [
        "react ui",
        "typescript cli",
    ],
    "packageNames": [
        "react",
        "@types/node",
        "typescript",
    ],
    "mode": "both",
    "maxResultsPerQuery": 20,
    "maxItems": 20,
    "enrichMetadata": True,
    "enrichDownloads": False,
    "downloadsPeriod": "last-month",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/npm-package-intelligence-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 '{
  "queries": [
    "react ui",
    "typescript cli"
  ],
  "packageNames": [
    "react",
    "@types/node",
    "typescript"
  ],
  "mode": "both",
  "maxResultsPerQuery": 20,
  "maxItems": 20,
  "enrichMetadata": true,
  "enrichDownloads": false,
  "downloadsPeriod": "last-month"
}' |
apify call automation-lab/npm-package-intelligence-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NPM Package Intelligence Scraper",
        "description": "Search npm packages and enrich them with registry metadata, downloads, maintainers, dependencies, links, and scoring signals.",
        "version": "0.1",
        "x-build-id": "HZySK3uE1rVSf5EQx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~npm-package-intelligence-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-npm-package-intelligence-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/automation-lab~npm-package-intelligence-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-npm-package-intelligence-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/automation-lab~npm-package-intelligence-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-npm-package-intelligence-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": {
                    "queries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Keywords to search on the public npm Registry, such as react ui, typescript cli, or pdf parser.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "packageNames": {
                        "title": "Exact package names",
                        "type": "array",
                        "description": "Optional exact npm package names to enrich, including scoped packages like @types/node.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "mode": {
                        "title": "Run mode",
                        "enum": [
                            "search",
                            "packages",
                            "both"
                        ],
                        "type": "string",
                        "description": "Use keyword search, exact package enrichment, or both sources.",
                        "default": "both"
                    },
                    "maxResultsPerQuery": {
                        "title": "Maximum results per query",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "How many search results to collect for each query. Keep the prefill small for cheap test runs.",
                        "default": 20
                    },
                    "maxItems": {
                        "title": "Maximum total packages",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Hard cap across search and exact package inputs.",
                        "default": 20
                    },
                    "enrichMetadata": {
                        "title": "Fetch package metadata",
                        "type": "boolean",
                        "description": "Fetch registry package documents for versions, dependencies, links, license, and maintainers.",
                        "default": true
                    },
                    "enrichDownloads": {
                        "title": "Fetch download counts",
                        "type": "boolean",
                        "description": "Fetch npm downloads API counts for each package and selected period.",
                        "default": false
                    },
                    "downloadsPeriod": {
                        "title": "Downloads period",
                        "enum": [
                            "last-day",
                            "last-week",
                            "last-month"
                        ],
                        "type": "string",
                        "description": "Period used by the npm downloads API when enrichment is enabled.",
                        "default": "last-month"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```