# Deno Land X Modules Scraper (`parseforge/deno-land-x-modules-scraper`) Actor

Pull every third party module from the deno.land/x registry with name, description, GitHub star count, latest version, full version history, upload timestamps, and source repository. Browse the whole registry or target modules by name. Great for dependency audits and ecosystem research.

- **URL**: https://apify.com/parseforge/deno-land-x-modules-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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)

## 🦕 Deno Land X Modules Scraper

> 🚀 **Export the deno.land/x module registry in one run.** Pull module names, GitHub stars, latest versions, full version history, and source repos straight from the official apiland API.

> 🕒 **Last updated:** 2026-06-08 · **📊 Up to 16 fields** per record · live registry · one record per module

Turn the deno.land/x third party registry into clean, structured records you can drop into a dependency tracker, a package explorer, or a research notebook. List the exact modules you care about, or leave the field empty and page through the entire registry. Each record carries the GitHub star count, popularity score, latest version, the full version list, the upload timestamp of the latest release, and the GitHub repository the module is published from.

Coverage is the public deno.land/x registry as the apiland API serves it: every module's metadata, its complete version history, and the source repository behind it. No Deno account, no key, and no login are required.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Deno developers and library authors | Track versions and stars across dependencies |
| Platform and DevOps engineers | Audit third party modules used in a codebase |
| Ecosystem researchers and analysts | Map registry growth and module popularity |
| Tooling and dashboard builders | Seed a package explorer with live metadata |

### 📋 What the Deno Land X Modules Scraper does

This Actor calls the public apiland API behind deno.land/x and returns one clean record per module:

- **Identity** — module name, description, and the canonical deno.land/x URL.
- **Popularity** — GitHub star count, popularity score, and registry tags.
- **Versions** — latest version, total version count, and the full version list.
- **Provenance** — the GitHub repository, optional subdirectory, and the upload timestamp of the latest release.

You either pass a list of module names or browse the whole registry, and you control how many records come back. Every record carries a `scrapedAt` timestamp.

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

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `modules` | array | Exact module names to scrape, for example `oak`, `zod`, or `std`. Leave empty to browse the whole registry. |
| `includeVersions` | boolean | When on, each record includes the full version list. The latest version and its upload timestamp are always returned. Defaults to `true`. |
| `maxItems` | integer | How many records to return. Free plan is capped at 10. |

**Example 1 — specific modules with full version history**
```json
{
    "modules": ["oak", "zod", "std"],
    "includeVersions": true,
    "maxItems": 3
}
````

**Example 2 — browse the registry, latest version only**

```json
{
    "includeVersions": false,
    "maxItems": 100
}
```

> ⚠️ **Good to Know:** the registry list endpoint omits the source repository, so for browse runs the Actor fetches each module's latest version metadata to fill in the GitHub repo and upload timestamp. That means one extra request per module, which is normal and keeps every record complete.

### 📊 Output

Each module record looks like this:

| Field | Description |
|---|---|
| 📦 `name` | deno.land/x module name |
| 📝 `description` | Module description |
| ⭐ `starCount` | GitHub star count |
| 📈 `popularityScore` | Registry popularity score |
| 🏷 `latestVersion` | Newest published version |
| 🔢 `versionCount` | Number of published versions |
| 📅 `latestVersionUploadedAt` | Upload timestamp of the latest version |
| 🐙 `repository` | GitHub `owner/repo` slug |
| 🔗 `repositorySource` | Full GitHub repository URL |
| 📁 `repositorySubdir` | Subdirectory the module is published from, if any |
| 🗂 `tags` | Registry tags, for example `top_1_percent` |
| 🌐 `url` | Canonical deno.land/x page |
| 🛰 `registryApiUrl` | apiland API URL for the module |
| 📜 `versions` | Full list of published versions (when enabled) |
| 🕒 `scrapedAt` | Collection timestamp |
| ❌ `error` | Null on success |

**Real sample — oak**

```json
{
    "name": "oak",
    "description": "A middleware framework for handling HTTP with Deno, Node, Bun and Cloudflare Workers 🐿️ 🦕",
    "starCount": 4731,
    "popularityScore": 180462,
    "latestVersion": "v17.2.0",
    "versionCount": 103,
    "latestVersionUploadedAt": "2025-11-22T01:00:22.287Z",
    "repository": "oakserver/oak",
    "repositorySource": "https://github.com/oakserver/oak",
    "repositorySubdir": null,
    "tags": ["top_1_percent"],
    "url": "https://deno.land/x/oak",
    "registryApiUrl": "https://apiland.deno.dev/v2/modules/oak",
    "versions": ["v17.2.0", "v17.1.6", "v17.1.5", "v17.1.4"],
    "scrapedAt": "2026-06-08T17:43:16.007Z",
    "error": null
}
```

**Real sample — zod**

```json
{
    "name": "zod",
    "description": "TypeScript-first schema validation with static type inference",
    "starCount": 19572,
    "popularityScore": 117073,
    "latestVersion": "v3.25",
    "versionCount": 82,
    "latestVersionUploadedAt": "2025-05-21T00:10:18.916Z",
    "repository": "colinhacks/zod",
    "repositorySource": "https://github.com/colinhacks/zod",
    "repositorySubdir": "deno/lib/",
    "tags": ["top_1_percent"],
    "url": "https://deno.land/x/zod",
    "registryApiUrl": "https://apiland.deno.dev/v2/modules/zod",
    "versions": ["v3.25", "v3.24.4", "v3.24.3", "v3.24.2"],
    "scrapedAt": "2026-06-08T17:43:16.352Z",
    "error": null
}
```

**Real sample — std**

```json
{
    "name": "std",
    "description": "The Deno Standard Library",
    "starCount": 2565,
    "popularityScore": 615,
    "latestVersion": "0.224.0",
    "versionCount": 190,
    "latestVersionUploadedAt": "2024-04-25T03:01:10.742Z",
    "repository": "denoland/deno_std",
    "repositorySource": "https://github.com/denoland/deno_std",
    "repositorySubdir": null,
    "tags": [],
    "url": "https://deno.land/x/std",
    "registryApiUrl": "https://apiland.deno.dev/v2/modules/std",
    "versions": ["0.224.0", "0.223.0", "0.222.1", "0.222.0"],
    "scrapedAt": "2026-06-08T17:43:16.650Z",
    "error": null
}
```

### ✨ Why choose this Actor

- One clean record per module, with consistent field names that map onto a database schema.
- Two ways to run, by name list or full registry browse, from a single input.
- Version history and the latest upload timestamp come ready, not buried behind extra calls.
- The GitHub source repository is resolved for every record, even in browse mode.
- No Deno account, no key, and no login required.

### 📈 How it compares to alternatives

| Approach | Effort | Structured fields | Version history | Maintenance |
|---|---|---|---|---|
| This Actor | One run | Yes | Yes | None on your side |
| Browsing deno.land/x by hand | Hours | Inconsistent | Manual | Constant |
| Writing your own apiland client | Days | Depends | Manual | You own the upkeep |

### 🚀 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 Deno Land X Modules Scraper.
3. Add module names to `modules`, or leave it empty to browse the registry.
4. Set `maxItems` and toggle `includeVersions` to taste.
5. Click **Start** and grab your results when the run finishes.

### 💼 Business use cases

#### Dependency management

| Goal | How this helps |
|---|---|
| Audit third party modules in a project | Pull stars, latest version, and source repo for each |
| Spot stale dependencies | Compare `latestVersion` and `latestVersionUploadedAt` |

#### Developer tooling

| Goal | How this helps |
|---|---|
| Build a package explorer | Seed it with live registry metadata |
| Power an upgrade checker | Track version counts and newest releases |

#### Ecosystem research

| Goal | How this helps |
|---|---|
| Measure registry growth | Browse the full module list on a schedule |
| Rank modules by reach | Sort by star count and popularity score |

#### Content and reporting

| Goal | How this helps |
|---|---|
| Write a "top Deno modules" roundup | Use real stars and popularity scores |
| Track a module's release cadence | Read its full version list and timestamps |

### 🔌 Automating Deno Land X Modules Scraper

Connect runs to the tools you already use:

- **Make** and **Zapier** to trigger runs and route records into sheets or databases.
- **Slack** to post a summary when a run finishes.
- **Airbyte** to load results into a warehouse.
- **GitHub** Actions to schedule periodic snapshots.
- **Google Drive** to archive each run's output.

### 🌟 Beyond business use cases

- **Research:** study how the Deno module ecosystem grows over time.
- **Personal:** keep a watchlist of your favorite Deno libraries.
- **Non-profit:** maintain a community list of vetted modules.
- **Experimentation:** prototype a registry dashboard without writing a scraper.

### 🤖 Ask an AI assistant

Paste your results into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Microsoft Copilot](https://copilot.microsoft.com) and ask it to rank modules by stars, group them by repository owner, or flag dependencies that have not shipped a release in a while.

### ❓ Frequently Asked Questions

**Do I need a Deno or GitHub account?**
No. The Actor reads the public apiland API behind deno.land/x, which needs no login.

**Do I need an API key?**
No key is required.

**Can I scrape the whole registry?**
Yes. Leave `modules` empty and the Actor pages through every module up to your `maxItems`.

**Can I target specific modules?**
Yes. List exact names like `oak`, `zod`, or `std` in the `modules` field.

**Where does the star count come from?**
It is the GitHub star count for the module's source repository, as reported by the registry.

**What is the popularity score?**
A ranking value the registry computes from recent traffic. The Actor passes through what the source provides.

**Do I get every published version?**
Yes when `includeVersions` is on. The latest version and its upload timestamp are always included.

**Why is `repositorySubdir` sometimes null?**
Some modules publish from the repository root, so there is no subdirectory. Others, like zod, publish from a path such as `deno/lib/`.

**How fresh is the data?**
Each run pulls live from the registry, so it reflects the catalog at run time.

**Can I schedule this?**
Yes. Use Apify Schedules to snapshot the registry on any cadence.

### 🔌 Integrate with any app

Results are available through the Apify API, so you can pull them into any app, database, or workflow you already run.

### 🔗 Recommended Actors

- [Have I Been Pwned Breaches Catalog Scraper](https://apify.com/parseforge)
- [Brawlify Brawl Stars Database Scraper](https://apify.com/parseforge)
- More developer and reference data Actors in the [ParseForge collection](https://apify.com/parseforge)

> 💡 **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 Deno or the Deno Land authors. Only publicly available data is collected.

# Actor input Schema

## `modules` (type: `array`):

Exact deno.land/x module names to scrape, for example 'oak', 'zod', or 'std'. Leave empty to browse the whole registry instead.

## `includeVersions` (type: `boolean`):

When on, each record includes the complete list of published versions and the upload timestamp of the latest version. When off, only the latest version and its timestamp are returned.

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

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

## Actor input object example

```json
{
  "modules": [
    "oak",
    "zod"
  ],
  "includeVersions": true,
  "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 = {
    "modules": [
        "oak",
        "zod"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/deno-land-x-modules-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 = {
    "modules": [
        "oak",
        "zod",
    ],
    "maxItems": 10,
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Deno Land X Modules Scraper",
        "description": "Pull every third party module from the deno.land/x registry with name, description, GitHub star count, latest version, full version history, upload timestamps, and source repository. Browse the whole registry or target modules by name. Great for dependency audits and ecosystem research.",
        "version": "0.1",
        "x-build-id": "ecXxCpj0QdQzglnKK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~deno-land-x-modules-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-deno-land-x-modules-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~deno-land-x-modules-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-deno-land-x-modules-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~deno-land-x-modules-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-deno-land-x-modules-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": {
                    "modules": {
                        "title": "Module names",
                        "type": "array",
                        "description": "Exact deno.land/x module names to scrape, for example 'oak', 'zod', or 'std'. Leave empty to browse the whole registry instead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeVersions": {
                        "title": "Include full version history",
                        "type": "boolean",
                        "description": "When on, each record includes the complete list of published versions and the upload timestamp of the latest version. When off, only the latest version and its timestamp are returned.",
                        "default": true
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
