# Docker Hub Repositories Scraper (`fetch_cat/docker-hub-repositories-scraper`) Actor

Export public Docker Hub repository and tag metadata including pulls, stars, digests, architectures, timestamps, and descriptions.

- **URL**: https://apify.com/fetch\_cat/docker-hub-repositories-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Developer tools, Automation, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.03 / 1,000 item extracteds

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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Docker Hub Repositories Scraper

Docker Hub Repositories Scraper helps teams turn public container image pages into clean datasets. Use it to compare popular base images, audit release cadence, inventory tag digests, and monitor public repository metadata without manual copying.

### Who is this for

- **DevOps and platform teams** tracking base image popularity, pulls, and tag freshness.
- **Security and supply-chain teams** exporting image digests, architectures, and timestamps for public dependencies.
- **Product and market researchers** comparing public container repository adoption across vendors.

### What data can it export

- Public repository identity, namespace, Docker Hub URL, descriptions, type, status, and trust flags.
- Pull counts, star counts, registration and update timestamps.
- Bounded tag metadata including tag names, IDs, digests, architecture, OS, image size, and push/pull timestamps.
- Namespace inventories for public Docker Hub organizations.

### Example input

```json
{
  "repositories": ["library/postgres", "library/redis"],
  "includeTags": true,
  "maxRepositories": 10,
  "maxTagsPerRepository": 5,
  "outputMode": "repositories"
}
````

### Example output

```json
{
  "type": "repository",
  "repository": "library/postgres",
  "namespace": "library",
  "name": "postgres",
  "hubUrl": "https://hub.docker.com/r/library/postgres",
  "shortDescription": "The PostgreSQL object-relational database system...",
  "starCount": 14962,
  "pullCount": 10980699991,
  "isOfficial": true,
  "tagCount": 1379,
  "tagLimitReached": true,
  "tags": [
    {
      "tagName": "latest",
      "imageDigest": "sha256:...",
      "architecture": "amd64",
      "os": "linux",
      "lastPushed": "2026-07-01T00:00:00Z"
    }
  ],
  "scrapedAt": "2026-07-14T00:00:00.000Z"
}
```

### Input settings

| Field | Type | Description |
| --- | --- | --- |
| `queries` | string\[] | Docker Hub search terms such as `postgres` or `redis`. |
| `repositories` | string\[] | Exact repositories as `namespace/name`; official images like `postgres` resolve to `library/postgres`. |
| `namespaces` | string\[] | Public namespaces to enumerate, such as `library` or `bitnami`. |
| `includeTags` | boolean | Fetch tag metadata for each repository. |
| `outputMode` | string | `repositories` for one row per repository with nested tags, or `tags` for one row per tag. |
| `maxRepositories` | integer | Maximum unique repositories to output. |
| `maxTagsPerRepository` | integer | Maximum tags to fetch per repository. |
| `descriptionMaxLength` | integer | Maximum characters kept from full descriptions. |
| `maxRuntimeSeconds` | integer | Optional self-imposed cap (31–270 seconds). Before it is reached, the Actor stops taking new repositories, writes `PENDING_REPOSITORIES`, and leaves time to shut down cleanly. |

### Output fields

Repository mode includes `repository`, `namespace`, `name`, `hubUrl`, `shortDescription`, `fullDescription`, `repositoryType`, `status`, `isPrivate`, `isOfficial`, `isAutomated`, `starCount`, `pullCount`, `dateRegistered`, `lastUpdated`, `lastModified`, `hubUser`, `sourceQueries`, `sourceInputs`, `tagCount`, `tagLimitReached`, `tags`, and `scrapedAt`.

Tag mode includes `repository`, `tagName`, `tagId`, `tagUrl`, `lastUpdated`, `lastPushed`, `lastPulled`, `fullSize`, `imageDigest`, `architecture`, `os`, `osVersion`, `variant`, `status`, `images`, and `scrapedAt`.

### Input recipes

**Search popular database images**

```json
{"queries":["postgres","mysql","redis"],"includeTags":true,"maxRepositories":30,"maxTagsPerRepository":3,"outputMode":"repositories"}
```

**Export tag digest inventory**

```json
{"repositories":["library/postgres"],"includeTags":true,"maxRepositories":5,"maxTagsPerRepository":25,"outputMode":"tags"}
```

**Enumerate a vendor namespace**

```json
{"namespaces":["bitnami"],"includeTags":false,"maxRepositories":50,"outputMode":"repositories"}
```

### Pricing

This Actor uses pay-per-event pricing:

- Start event: `$0.005` per run.
  Each saved repository row in repository mode, or each saved tag row in tag mode, is one paid item. Failed requests and diagnostic records are not charged.

| Apify usage tier | Price per saved item | Approx. price per 1,000 saved items |
| --- | ---: | ---: |
| Free | `$0.000057346` | 5.7346 cents |
| Starter / Bronze | `$0.000049866` | 4.9866 cents |
| Scale / Silver | `$0.000038895` | 3.8895 cents |
| Business / Gold | `$0.000029919` | 2.9919 cents |
| Platinum | `$0.000019946` | 1.9946 cents |
| Diamond | `$0.000013962` | 1.3962 cents |

### Tips and limits

- Keep `maxTagsPerRepository` bounded for official images with thousands of tags.
- Use `outputMode: "tags"` when you need a flat export of tag digests and architecture metadata.
- Use repository mode when you want one row per image with a compact nested tag sample.
- The Actor only exports public Docker Hub metadata and does not access private repositories or vulnerability scan data.
- Every repository is saved progressively. If the run approaches its time limit, `PENDING_REPOSITORIES` records the unprocessed work and `RUN_SUMMARY` explains what completed and why.
- Use `maxRuntimeSeconds` when you need a predictable bounded run. The pending-work record lists canonical repository names so you can run those names again in a later job; it never silently changes your search or namespace filters.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/docker-hub-repositories-scraper').call({
  repositories: ['library/postgres'],
  includeTags: true,
  maxTagsPerRepository: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('fetch_cat/docker-hub-repositories-scraper').call(run_input={
    'repositories': ['library/postgres'],
    'includeTags': True,
    'maxTagsPerRepository': 10,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~docker-hub-repositories-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"repositories":["library/postgres"],"includeTags":true,"maxTagsPerRepository":10}'
```

### MCP and agents

Use this Actor from AI agents through Apify MCP:

```bash
claude mcp add apify https://mcp.apify.com/?tools=fetch_cat/docker-hub-repositories-scraper
```

JSON config:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/docker-hub-repositories-scraper"
    }
  }
}
```

Example prompts:

- "Export the latest public tags for library/postgres from Docker Hub."
- "Find Docker Hub repositories matching redis and summarize pull counts."
- "Create a CSV of image digests and architectures for library/nginx."

### FAQ

**Can it scrape private repositories?** No. It only exports public Docker Hub metadata.

**Does it return vulnerability or SBOM data?** No. Those fields are not publicly available for arbitrary repositories.

**Why are tag counts capped?** Popular official images can have thousands of tags. The cap keeps runs fast and predictable.

### Related Actors

- [GitHub Repositories Search Scraper](https://apify.com/fetch_cat/github-repositories-search-scraper)
- [GitHub Trending Scraper](https://apify.com/fetch_cat/github-trending-scraper)
- [BuiltWith Domain Tech Stack Scraper](https://apify.com/fetch_cat/builtwith-domain-tech-stack-scraper)

### Support

Questions or issues? Open the Issues tab on the Actor page and include:

- The input JSON you used.
- The expected output.
- The actual output or error message.
- A reproducible public URL from Docker Hub, such as a repository or namespace page.
- Your Apify run ID.

# Actor input Schema

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

Docker Hub search terms, for example postgres, redis, or bitnami nginx.

## `repositories` (type: `array`):

Exact repositories as namespace/name. Official images can be entered as just the image name, for example postgres is resolved to library/postgres.

## `namespaces` (type: `array`):

Docker Hub namespaces to enumerate, for example library or bitnami.

## `includeTags` (type: `boolean`):

Fetch bounded tag metadata for each repository.

## `outputMode` (type: `string`):

Repository rows with nested tags, or one dataset row per tag.

## `maxRepositories` (type: `integer`):

Maximum unique repositories to emit across all inputs.

## `maxTagsPerRepository` (type: `integer`):

Maximum tags fetched for each repository when tag enrichment is enabled.

## `descriptionMaxLength` (type: `integer`):

Maximum characters kept from the full repository description. Set 0 to omit full descriptions.

## `maxRuntimeSeconds` (type: `integer`):

Optional self-imposed runtime cap in seconds. The Actor stops starting new repositories before this cap, saves pending repository work to PENDING\_REPOSITORIES, and leaves time for a clean shutdown. Default 270 seconds; minimum 31 seconds.

## Actor input object example

```json
{
  "queries": [
    "postgres"
  ],
  "repositories": [
    "library/postgres",
    "library/redis"
  ],
  "includeTags": true,
  "outputMode": "repositories",
  "maxRepositories": 20,
  "maxTagsPerRepository": 5,
  "descriptionMaxLength": 20,
  "maxRuntimeSeconds": 270
}
```

# Actor output Schema

## `apiDefaultDatasetUrl` (type: `string`):

No description

## `runSummary` (type: `string`):

No description

## `pendingRepositories` (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": [
        "postgres"
    ],
    "repositories": [
        "library/postgres",
        "library/redis"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/docker-hub-repositories-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": ["postgres"],
    "repositories": [
        "library/postgres",
        "library/redis",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/docker-hub-repositories-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": [
    "postgres"
  ],
  "repositories": [
    "library/postgres",
    "library/redis"
  ]
}' |
apify call fetch_cat/docker-hub-repositories-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Docker Hub Repositories Scraper",
        "description": "Export public Docker Hub repository and tag metadata including pulls, stars, digests, architectures, timestamps, and descriptions.",
        "version": "0.1",
        "x-build-id": "EAZg6i3M6flBNiR7d"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~docker-hub-repositories-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-docker-hub-repositories-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/fetch_cat~docker-hub-repositories-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-docker-hub-repositories-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/fetch_cat~docker-hub-repositories-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-docker-hub-repositories-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": "Docker Hub search terms, for example postgres, redis, or bitnami nginx.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "repositories": {
                        "title": "Repositories",
                        "type": "array",
                        "description": "Exact repositories as namespace/name. Official images can be entered as just the image name, for example postgres is resolved to library/postgres.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "namespaces": {
                        "title": "Namespaces",
                        "type": "array",
                        "description": "Docker Hub namespaces to enumerate, for example library or bitnami.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeTags": {
                        "title": "Include tags",
                        "type": "boolean",
                        "description": "Fetch bounded tag metadata for each repository.",
                        "default": true
                    },
                    "outputMode": {
                        "title": "Output mode",
                        "enum": [
                            "repositories",
                            "tags"
                        ],
                        "type": "string",
                        "description": "Repository rows with nested tags, or one dataset row per tag.",
                        "default": "repositories"
                    },
                    "maxRepositories": {
                        "title": "Maximum repositories",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum unique repositories to emit across all inputs.",
                        "default": 20
                    },
                    "maxTagsPerRepository": {
                        "title": "Maximum tags per repository",
                        "minimum": 0,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum tags fetched for each repository when tag enrichment is enabled.",
                        "default": 5
                    },
                    "descriptionMaxLength": {
                        "title": "Description maximum length",
                        "minimum": 0,
                        "maximum": 20000,
                        "type": "integer",
                        "description": "Maximum characters kept from the full repository description. Set 0 to omit full descriptions.",
                        "default": 20
                    },
                    "maxRuntimeSeconds": {
                        "title": "Maximum runtime",
                        "minimum": 31,
                        "maximum": 270,
                        "type": "integer",
                        "description": "Optional self-imposed runtime cap in seconds. The Actor stops starting new repositories before this cap, saves pending repository work to PENDING_REPOSITORIES, and leaves time for a clean shutdown. Default 270 seconds; minimum 31 seconds.",
                        "default": 270
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```