# Project Gutenberg Scraper (`crawlerbros/project-gutenberg-scraper`) Actor

Search and download Project Gutenberg's 75,000+ free ebooks. Filter by keyword, topic, language, author era, copyright status, and available format (EPUB, Kindle, PDF, plain text).

- **URL**: https://apify.com/crawlerbros/project-gutenberg-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Project Gutenberg Scraper

Search and download from Project Gutenberg's library of 75,000+ free ebooks — public-domain classics, poetry, philosophy, and more. Search by keyword, browse by topic or language, filter by author era or copyright status, and get direct download links (EPUB, Kindle/MOBI, PDF, plain text, HTML) plus full bibliographic metadata. No auth, no proxy, no cost add-ons.

### What this actor does

- **Two modes:** `search` (keyword / topic / language / era / copyright / format filters) and `byIds` (fetch specific books by their Project Gutenberg ID numbers)
- **Rich filters:** free-text search, subject/bookshelf topic, language, copyright status, author's era (including BCE years for classical authors), available file format
- **Sort:** most popular (by download count), or by Gutenberg ID ascending/descending
- **Download links:** direct URLs for every format the book is available in
- **Empty fields are omitted** — every record only contains what could actually be found

### Output per book

- `gutenbergId` — Project Gutenberg ID number
- `gutenbergUrl` — the book's page on gutenberg.org
- `title`
- `authors[]` — `{ name, birthYear, deathYear }`, `primaryAuthor`
- `translators[]`
- `summary` — auto-generated synopsis (where available)
- `subjects[]`, `bookshelves[]`
- `languages[]` — ISO 639-1 codes
- `copyright` — `true` (copyrighted), `false` (public domain in the USA); omitted if unknown
- `mediaType`
- `downloadCount`
- `readOnlineUrl`, `epubUrl`, `mobiUrl`, `pdfUrl`, `plainTextUrl`, `coverImageUrl`, `metadataUrl` — only included when that format actually exists for the book
- `recordType: "book"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` or `byIds` |
| `searchQuery` | string | `shakespeare` | Search title / author name |
| `topic` | string | – | Key phrase to search in subjects/bookshelves |
| `languages` | array | – | One or more language codes |
| `copyrightStatus` | string | `any` | `any` / `publicDomain` / `copyrighted` / `unknown` |
| `sortBy` | string | `popular` | `popular` / `ascending` / `descending` |
| `authorYearFrom` | int | – | Only authors alive on/after this year (negative = BCE) |
| `authorYearTo` | int | – | Only authors alive on/before this year |
| `mimeType` | string | `any` | Only books available in this format |
| `gutenbergIds` | array | – | Gutenberg ID numbers (mode=byIds) |
| `maxItems` | int | `20` | Hard cap (1–500) |

#### Example: search by keyword

```json
{
  "mode": "search",
  "searchQuery": "sherlock holmes",
  "maxItems": 20
}
````

#### Example: browse a topic in a given language

```json
{
  "mode": "search",
  "topic": "science fiction",
  "languages": ["en"],
  "sortBy": "popular",
  "maxItems": 50
}
```

#### Example: classical (BCE) authors only

```json
{
  "mode": "search",
  "authorYearTo": -1,
  "maxItems": 30
}
```

#### Example: fetch specific books by ID

```json
{
  "mode": "byIds",
  "gutenbergIds": ["2701", "1342", "84"]
}
```

### Use cases

- **Ebook apps / readers** — bulk-import public-domain titles with ready-to-use EPUB/MOBI links
- **NLP / text-mining research** — source large volumes of plain-text classics for corpus building
- **Recommendation engines** — feed subject/bookshelf taxonomy into a recommender
- **Digital libraries & archives** — mirror or index public-domain collections
- **Education** — curate reading lists by era, language, or topic
- **Content sites** — surface classic literature with legal, direct download links

### FAQ

**What's Project Gutenberg?** The oldest digital library, offering over 75,000 free ebooks — mostly older works whose U.S. copyright has expired. See [gutenberg.org](https://www.gutenberg.org).

**Are these books really free to use?** Public-domain titles (the vast majority) can be freely copied, shared, and reused. Titles marked `copyright: true` retain some rights — check `metadataUrl` for details.

**What formats are available?** Most books have HTML, EPUB, and plain text at minimum. Many also have Kindle/MOBI. PDF and cover images are available for a smaller subset — the actor only includes a link when that format actually exists for the book.

**How is "popular" determined?** By total number of downloads recorded by Project Gutenberg — a good proxy for how well-known a title is.

**What do `authorYearFrom` / `authorYearTo` do?** They filter to books with at least one author alive within that year range — useful for finding books from a specific literary era. Use negative numbers for BCE (e.g. `-499` for authors alive around 500 BCE, useful for classical texts like Homer or Plato).

**Can I search in a specific language?** Yes — set `languages` to one or more ISO 639-1 codes (e.g. `en`, `fr`, `de`). Leave empty to search all languages.

**Is there a rate limit?** No API key or login required; the actor uses small delays between pages to be a good citizen.

**How fresh is the data?** Project Gutenberg adds new public-domain digitizations regularly; this actor always fetches live.

# Actor input Schema

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

`search` finds books by keyword/filters. `byIds` fetches specific books by their Project Gutenberg ID numbers.

## `searchQuery` (type: `string`):

Search book titles and author names, e.g. a title word, phrase, or author's name.

## `topic` (type: `string`):

Case-insensitive key phrase to search in a book's bookshelves or subjects, e.g. `children`, `science fiction`, `poetry`.

## `languages` (type: `array`):

Filter to books in one or more of these languages. Leave empty for all languages.

## `copyrightStatus` (type: `string`):

Filter by copyright status as recorded by Project Gutenberg.

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

`popular` sorts by number of downloads (default). `ascending`/`descending` sort by Project Gutenberg ID number.

## `authorYearFrom` (type: `integer`):

Only include books with at least one author alive on or after this year. Use negative numbers for BCE (e.g. -499 for 500 BCE).

## `authorYearTo` (type: `integer`):

Only include books with at least one author alive on or before this year. Use negative numbers for BCE.

## `mimeType` (type: `string`):

Only include books that are available in this file format.

## `gutenbergIds` (type: `array`):

Project Gutenberg ID numbers to fetch directly. Required when Mode is `byIds`.

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "shakespeare",
  "languages": [],
  "copyrightStatus": "any",
  "sortBy": "popular",
  "mimeType": "any",
  "gutenbergIds": [
    "2701",
    "1342"
  ],
  "maxItems": 20
}
```

# Actor output Schema

## `books` (type: `string`):

Dataset containing all scraped Project Gutenberg books.

# 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 = {
    "mode": "search",
    "searchQuery": "shakespeare",
    "languages": [],
    "copyrightStatus": "any",
    "sortBy": "popular",
    "mimeType": "any",
    "gutenbergIds": [
        "2701",
        "1342"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/project-gutenberg-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 = {
    "mode": "search",
    "searchQuery": "shakespeare",
    "languages": [],
    "copyrightStatus": "any",
    "sortBy": "popular",
    "mimeType": "any",
    "gutenbergIds": [
        "2701",
        "1342",
    ],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/project-gutenberg-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 '{
  "mode": "search",
  "searchQuery": "shakespeare",
  "languages": [],
  "copyrightStatus": "any",
  "sortBy": "popular",
  "mimeType": "any",
  "gutenbergIds": [
    "2701",
    "1342"
  ],
  "maxItems": 20
}' |
apify call crawlerbros/project-gutenberg-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Project Gutenberg Scraper",
        "description": "Search and download Project Gutenberg's 75,000+ free ebooks. Filter by keyword, topic, language, author era, copyright status, and available format (EPUB, Kindle, PDF, plain text).",
        "version": "1.0",
        "x-build-id": "ldr9ANkrLR04cGHBT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~project-gutenberg-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-project-gutenberg-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/crawlerbros~project-gutenberg-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-project-gutenberg-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/crawlerbros~project-gutenberg-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-project-gutenberg-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byIds"
                        ],
                        "type": "string",
                        "description": "`search` finds books by keyword/filters. `byIds` fetches specific books by their Project Gutenberg ID numbers.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Search book titles and author names, e.g. a title word, phrase, or author's name.",
                        "default": "shakespeare"
                    },
                    "topic": {
                        "title": "Topic / subject",
                        "type": "string",
                        "description": "Case-insensitive key phrase to search in a book's bookshelves or subjects, e.g. `children`, `science fiction`, `poetry`."
                    },
                    "languages": {
                        "title": "Languages",
                        "type": "array",
                        "description": "Filter to books in one or more of these languages. Leave empty for all languages.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "en",
                                "fr",
                                "fi",
                                "de",
                                "nl",
                                "it",
                                "es",
                                "hu",
                                "pt",
                                "zh",
                                "sv",
                                "el",
                                "la",
                                "eo",
                                "ca",
                                "da",
                                "tl",
                                "pl",
                                "no",
                                "ja",
                                "fy",
                                "af",
                                "cy",
                                "cs",
                                "ru",
                                "he",
                                "is",
                                "enm",
                                "ro",
                                "ga",
                                "sl",
                                "sr",
                                "ang",
                                "gl",
                                "grc",
                                "myn",
                                "nah",
                                "ceb",
                                "oc",
                                "ar",
                                "br",
                                "yi",
                                "ko",
                                "fa",
                                "sa",
                                "iu",
                                "oji",
                                "lt",
                                "et",
                                "kha"
                            ],
                            "enumTitles": [
                                "English",
                                "French",
                                "Finnish",
                                "German",
                                "Dutch",
                                "Italian",
                                "Spanish",
                                "Hungarian",
                                "Portuguese",
                                "Chinese",
                                "Swedish",
                                "Greek (Modern)",
                                "Latin",
                                "Esperanto",
                                "Catalan",
                                "Danish",
                                "Tagalog",
                                "Polish",
                                "Norwegian",
                                "Japanese",
                                "Frisian",
                                "Afrikaans",
                                "Welsh",
                                "Czech",
                                "Russian",
                                "Hebrew",
                                "Icelandic",
                                "Middle English",
                                "Romanian",
                                "Irish",
                                "Slovenian",
                                "Serbian",
                                "Old English",
                                "Galician",
                                "Greek (Ancient)",
                                "Mayan languages",
                                "Nahuatl",
                                "Cebuano",
                                "Occitan",
                                "Arabic",
                                "Breton",
                                "Yiddish",
                                "Korean",
                                "Persian",
                                "Sanskrit",
                                "Inuktitut",
                                "Ojibwa",
                                "Lithuanian",
                                "Estonian",
                                "Khasi"
                            ]
                        },
                        "default": []
                    },
                    "copyrightStatus": {
                        "title": "Copyright status",
                        "enum": [
                            "any",
                            "publicDomain",
                            "copyrighted",
                            "unknown"
                        ],
                        "type": "string",
                        "description": "Filter by copyright status as recorded by Project Gutenberg.",
                        "default": "any"
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "popular",
                            "ascending",
                            "descending"
                        ],
                        "type": "string",
                        "description": "`popular` sorts by number of downloads (default). `ascending`/`descending` sort by Project Gutenberg ID number.",
                        "default": "popular"
                    },
                    "authorYearFrom": {
                        "title": "Author alive from year",
                        "minimum": -3000,
                        "maximum": 2026,
                        "type": "integer",
                        "description": "Only include books with at least one author alive on or after this year. Use negative numbers for BCE (e.g. -499 for 500 BCE)."
                    },
                    "authorYearTo": {
                        "title": "Author alive to year",
                        "minimum": -3000,
                        "maximum": 2026,
                        "type": "integer",
                        "description": "Only include books with at least one author alive on or before this year. Use negative numbers for BCE."
                    },
                    "mimeType": {
                        "title": "Available format",
                        "enum": [
                            "any",
                            "text/html",
                            "application/epub+zip",
                            "application/x-mobipocket-ebook",
                            "application/pdf",
                            "text/plain",
                            "image/jpeg",
                            "application/rdf+xml"
                        ],
                        "type": "string",
                        "description": "Only include books that are available in this file format.",
                        "default": "any"
                    },
                    "gutenbergIds": {
                        "title": "Gutenberg IDs",
                        "type": "array",
                        "description": "Project Gutenberg ID numbers to fetch directly. Required when Mode is `byIds`.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
