# Genius Lyrics Scraper | Songs Artists and Annotations (`parseforge/genius-lyrics-scraper`) Actor

Scrape song lyrics, artist pages, album info, release dates, producers, writers, and Genius annotations. Build music datasets, lyric search apps, NLP corpora, sentiment analysis pipelines, and song recommendation tools from one of the largest lyric archives online.

- **URL**: https://apify.com/parseforge/genius-lyrics-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** For creators, Social media, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🎵 Genius Lyrics Scraper

> 🚀 **Export song metadata and lyrics from Genius in seconds.** Search any artist, song title, or keyword and get structured data including lyrics, annotations, page views, and release dates - ready to download as CSV, Excel, JSON, or XML.

> 🕒 **Last updated:** 2026-05-22 · **📊 12 fields** per record · **Scales to 1,000,000 items** · **Global coverage**

The Genius Lyrics Scraper lets you extract structured song data from [Genius.com](https://genius.com), the world's largest song lyrics and music knowledge database. Every record contains the song title, artist, URL, release date, annotation count, page views, featured artists, and optionally the full lyrics text - all pulled from Genius's live data in real time.

The dataset covers all artists and genres available on Genius - from hip-hop and pop to rock, country, and classical. Whether you need a handful of records for a quick project or millions of entries for large-scale NLP training, the scraper handles it.

**Target Audience / Use Cases**

| Who | What They Need |
|-----|---------------|
| Music researchers | Metadata and lyrics for corpus analysis |
| NLP / ML engineers | Lyric text for language model training data |
| Data journalists | Artist popularity signals (pageviews, annotations) |
| Playlist curators | Release dates and featured artist mapping |
| Music educators | Annotated lyrics and song breakdowns |
| Fans and bloggers | Complete song metadata for any artist |

### 📋 What the Genius Lyrics Scraper does

- Search Genius by artist name, song title, or any keyword
- Returns song title, artist, Genius URL, release date, annotation count, and page view stats
- Optionally fetches full lyrics for each song (one extra request per song)
- Extracts featured artist lists
- Paginates automatically to collect as many results as needed
- Limits free users to 10 items; paid users can extract up to 1,000,000

> 💡 **Why it matters:** Genius has over 5 million annotated songs - the richest publicly available source of lyrics, artist metadata, and crowd-sourced music knowledge on the internet.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `searchQuery` | string | `Drake` | Artist name, song title, or keywords |
| `includeLyrics` | boolean | `false` | Fetch full lyrics for each song (slower) |
| `maxItems` | integer | `10` | Max records to return (free: 10, paid: up to 1,000,000) |

**Example - metadata only (fast):**
```json
{
    "searchQuery": "Taylor Swift",
    "includeLyrics": false,
    "maxItems": 50
}
````

**Example - with lyrics:**

```json
{
    "searchQuery": "Eminem Lose Yourself",
    "includeLyrics": true,
    "maxItems": 10
}
```

> ⚠️ **Good to Know:** When `includeLyrics` is enabled, the scraper makes one additional HTTP request per song to fetch the lyrics page. For large datasets, this significantly increases runtime. For metadata-only use cases, leave `includeLyrics` set to `false`.

### 📊 Output

| Field | Type | Description |
|-------|------|-------------|
| 🖼️ `imageUrl` | string | Song header image URL |
| 🎵 `title` | string | Song title |
| 🎤 `artist` | string | Primary artist name |
| 🔗 `url` | string | Genius song page URL |
| 💿 `albumName` | string or null | Album name (not available in search results) |
| 📅 `releaseDate` | string | Release date as shown on Genius |
| 📝 `annotationCount` | integer | Number of annotations on the song |
| 👁️ `pageviews` | integer | Page view count |
| 👥 `featuredArtists` | array | List of featured artist names |
| 📖 `lyrics` | string or null | Full lyrics text (only when `includeLyrics=true`) |
| 🕒 `scrapedAt` | string | ISO timestamp of extraction |
| ❌ `error` | string or null | Error message if extraction failed |

**Sample record:**

```json
{
    "imageUrl": "https://images.genius.com/3bfbcd7698edb8782c6634ce6dcaab17.1000x1000x1.png",
    "title": "God's Plan",
    "artist": "Drake",
    "url": "https://genius.com/Drake-gods-plan-lyrics",
    "albumName": null,
    "releaseDate": "January 19, 2018",
    "annotationCount": 20,
    "pageviews": 10041404,
    "featuredArtists": [],
    "lyrics": "[Intro]\nAnd they wishin' and wishin'\nAnd wishin' and wishin', they wishin' on me\nYeah\n\n[Verse 1]\nI been movin' calm, don't start no trouble with me...",
    "scrapedAt": "2026-05-22T01:54:39.924Z",
    "error": null
}
```

**Note:** `albumName` is `null` in search results. Genius does not include album data in the multi-search API response. All other fields are consistently populated.

### ✨ Why choose this Actor

| Feature | Detail |
|---------|--------|
| 🚀 No login required | Public data only, no Genius account needed |
| 🎯 Internal API | Uses Genius's internal search API for reliable structured data |
| 📖 Real lyrics | Extracts clean lyrics text with section headers (\[Verse 1], \[Chorus], etc.) |
| 📊 Popularity signals | Page views and annotation counts for every song |
| ⚡ Fast by default | Metadata-only mode skips lyrics fetching for maximum speed |
| 🔁 Paginated | Automatically pages through results for large datasets |
| 💼 Structured output | Clean JSON ready for CSV/Excel export |

### 📈 How it compares to alternatives

| Feature | This Actor | Manual copy-paste | Genius API (official) |
|---------|-----------|------------------|----------------------|
| Requires auth | No | No | Yes (API key) |
| Bulk export | Yes | No | Limited |
| Lyrics included | Optional | Manual | Yes |
| Structured data | Yes | No | Yes |
| Page views | Yes | No | Yes |
| Pagination | Automatic | Manual | Manual |

### 🚀 How to use

1. [Create a free Apify account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)
2. Open the Genius Lyrics Scraper actor page
3. Enter your search query (artist name, song title, or keywords)
4. Choose whether to include lyrics
5. Set `maxItems` (10 for free, up to 1,000,000 for paid)
6. Click **Start** and wait for the run to complete
7. Download your dataset as CSV, Excel, JSON, or XML

### 💼 Business use cases

#### Music Research and Analytics

Track which songs dominate search results for any artist, monitor annotation growth as a proxy for fan engagement, and analyze page view data to understand song popularity over time.

#### NLP Training Data

Build lyric corpora for language model training, sentiment analysis, rhyme detection, or genre classification. The `includeLyrics` option gives you clean, structured text with section markers intact.

#### Artist and Catalog Management

Map complete discographies, identify featured artist relationships, and extract release dates to build timelines. Cross-reference pageviews for catalog prioritization.

#### Playlist and Recommendation Systems

Pull metadata for large song catalogs to power recommendation engines. Use artist, featured artists, and release date fields as training signals for collaborative filtering models.

### 🔌 Automating Genius Lyrics Scraper

Connect this actor to your workflows using Apify integrations:

- **Make (Integromat)** - trigger on schedule, push results to Google Sheets
- **Zapier** - send new lyrics data to Slack, Notion, or Airtable
- **Apify API** - call programmatically from any application
- **Webhooks** - receive dataset updates when a run completes

### 🌟 Beyond business use cases

#### Academic Research

Study linguistic patterns in popular music, analyze how lyrical complexity correlates with commercial success, or trace cultural references across decades of song lyrics.

#### Fan Projects

Build artist discography databases, create lyric search tools, or generate statistics about your favorite artists' catalog.

#### Non-profit and Education

Develop educational tools around song analysis, music history projects, or media literacy curricula using real-world lyric data.

#### Experimentation

Train text generation models on lyrics, experiment with rhyme detection algorithms, or build genre classifiers using Genius metadata as ground truth labels.

### 🤖 Ask an AI assistant about this scraper

You can ask an AI assistant questions like:

- "How do I scrape lyrics for all of Taylor Swift's songs?"
- "What fields does the Genius Lyrics Scraper return?"
- "How do I export the data to a spreadsheet?"

### ❓ Frequently Asked Questions

**🔑 Do I need a Genius account or API key?**
No. The scraper uses Genius's public search API and public song pages. No account or API key is required.

**📖 How accurate are the lyrics?**
Lyrics are sourced directly from Genius song pages, the same content you see when visiting genius.com in your browser. Genius lyrics are crowd-sourced and reviewed by the community.

**💿 Why is albumName always null?**
Genius's multi-search API does not include album data in search results. The album field is available on individual song API endpoints, which would require a separate request per song. This may be added in a future version.

**⚡ How fast is the scraper?**
Without lyrics: very fast - typically 5 songs per API call, dozens of calls per minute. With lyrics enabled, each song requires an additional page request, reducing throughput proportionally.

**📊 How many results can I get?**
Free users: up to 10 items. Paid users: up to 1,000,000 items. Results per search query are limited by Genius's index size for that query.

**🌍 Does it work for all languages?**
Yes. Genius indexes songs in all languages. Search in any language and lyrics will be returned in their original language.

**🔄 Can I search multiple artists at once?**
Run the actor multiple times with different `searchQuery` values, or use Apify's API to trigger multiple runs in parallel.

**📅 How fresh is the data?**
All data is scraped in real time from Genius on every run. No cached responses are used.

**🛡️ Is this allowed?**
This scraper accesses only publicly available data that anyone can view without logging in on genius.com.

**💳 What happens if I'm on the free plan?**
Free users receive up to 10 results per run as a preview. [Upgrade to a paid plan](https://console.apify.com/sign-up?fpr=vmoqkp) to unlock up to 1,000,000 results.

### 🔌 Integrate with any app

Export your dataset and use it with:
Google Sheets - Google Drive - Airtable - Notion - Slack - Microsoft Excel - PostgreSQL - MySQL - MongoDB - BigQuery - Snowflake - Zapier - Make - n8n - REST API - Python - JavaScript - R - any tool that reads JSON or CSV

### 🔗 Recommended Actors

| Actor | Description |
|-------|-------------|
| [Spotify Scraper](https://apify.com/parseforge) | Extract track metadata, playlists, and artist data from Spotify |
| [YouTube Scraper](https://apify.com/parseforge) | Scrape video metadata, comments, and channel data from YouTube |
| [SoundCloud Scraper](https://apify.com/parseforge) | Extract tracks, playlists, and artist profiles from SoundCloud |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) to find scrapers for hundreds of websites - all built to the same quality standard.

***

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** This actor is an independent tool, not affiliated with, endorsed by, or sponsored by Genius. It accesses only publicly available data. Use responsibly and in accordance with Genius's terms of service.

# Actor input Schema

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

Search by artist name, song title, or keywords (e.g. 'Drake', 'Eminem Lose Yourself', 'Taylor Swift')

## `includeLyrics` (type: `boolean`):

If enabled, fetches full lyrics for each song (slower, uses more requests)

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

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

## Actor input object example

```json
{
  "searchQuery": "Drake",
  "includeLyrics": false,
  "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 = {
    "searchQuery": "Drake",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/genius-lyrics-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 = {
    "searchQuery": "Drake",
    "maxItems": 10,
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Genius Lyrics Scraper | Songs Artists and Annotations",
        "description": "Scrape song lyrics, artist pages, album info, release dates, producers, writers, and Genius annotations. Build music datasets, lyric search apps, NLP corpora, sentiment analysis pipelines, and song recommendation tools from one of the largest lyric archives online.",
        "version": "0.1",
        "x-build-id": "HencGuxH7u7Cxi1Yg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~genius-lyrics-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-genius-lyrics-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~genius-lyrics-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-genius-lyrics-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~genius-lyrics-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-genius-lyrics-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": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search by artist name, song title, or keywords (e.g. 'Drake', 'Eminem Lose Yourself', 'Taylor Swift')"
                    },
                    "includeLyrics": {
                        "title": "Include Lyrics",
                        "type": "boolean",
                        "description": "If enabled, fetches full lyrics for each song (slower, uses more requests)",
                        "default": false
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```