# Genius Scraper (`automation-lab/genius-scraper`) Actor

Extract song lyrics, metadata, and artist data from Genius.com. Get titles, full lyrics text, release dates, Spotify/YouTube/Apple Music links, writer and producer credits, and pageview stats. Search songs, scrape artist discographies, or target specific URLs. Export to JSON, CSV, or Excel.

- **URL**: https://apify.com/automation-lab/genius-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other, Education
- **Stats:** 66 total users, 3 monthly users, 98.6% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Genius Scraper

### What does Genius Scraper do?

**Genius Scraper** extracts song lyrics, metadata, and artist information from [Genius.com](https://genius.com) — the world's largest lyrics and music knowledge platform. Search for songs by keyword, scrape full artist discographies, or extract lyrics and details from specific song URLs. No API key or login required.

The scraper uses Genius's public API to collect **rich metadata** including release dates, Spotify/YouTube/Apple Music links, writer and producer credits, page view counts, and full lyrics text. It's the easiest way to get structured music data at scale.

Try it by clicking **Start** with the prefilled input — it searches for "Bohemian Rhapsody" and returns song data with lyrics.

### Who Is It For?

**Music researchers and analysts**
- Build datasets of song metadata across genres, decades, or artists
- Analyze lyrical themes, language patterns, and songwriting credits
- Track song popularity via Genius pageview statistics

**Content creators and marketers**
- Source accurate lyrics for video subtitles, karaoke apps, or music blogs
- Find Spotify/YouTube/Apple Music links for playlists and recommendations
- Research songwriter and producer credits for music journalism

**Data scientists and NLP engineers**
- Train language models on song lyrics corpora
- Perform sentiment analysis on lyrics across genres
- Build music recommendation systems using metadata features

**App developers**
- Power music discovery features with structured song data
- Integrate lyrics into music players or karaoke applications
- Build artist databases with discography and credit information

### Why use Genius Scraper?

- **No API key needed** — works out of the box, no Genius developer account required
- **Rich metadata** — not just lyrics: album info, release dates, credits, streaming links, pageviews
- **Three scraping modes** — search by keyword, scrape artist discographies, or target specific song URLs
- **Fast HTTP-only extraction** — no browser overhead, runs on 256 MB memory
- **Pay-per-result pricing** — only pay for songs you actually extract
- **Export anywhere** — JSON, CSV, Excel, or connect to 5,000+ apps via API
- **Scheduled runs** — monitor new releases or trending songs automatically
- **Proxy rotation** — reliable data collection with automatic IP rotation

### What data can you extract?

Each song result includes up to **25 data fields**:

| Category | Fields |
|----------|--------|
| 🎵 **Song info** | Title, Genius ID, URL, language, explicit flag |
| 👤 **Artist** | Name, ID, URL, image |
| 💿 **Album** | Name, URL, cover art |
| 📅 **Release** | Release date, recording location |
| 📝 **Lyrics** | Full lyrics text (plain text) |
| 📊 **Stats** | Pageviews, annotation count |
| 🔗 **Streaming** | Spotify URL, YouTube URL, Apple Music URL |
| ✍️ **Credits** | Writer names, producer names, featured artists |
| 📖 **Context** | Description/annotation preview |

### How much does it cost to scrape Genius?

This Actor uses **pay-per-event** pricing — you pay only for what you scrape.
No monthly subscription. All platform costs are **included**.

| | Free | Starter ($29/mo) | Scale ($199/mo) | Business ($999/mo) |
|---|---|---|---|---|
| **Per song** | $0.0069 | $0.006 | $0.00468 | $0.0036 |
| **1,000 songs** | $6.90 | $6.00 | $4.68 | $3.60 |

Higher-tier plans get additional volume discounts.

**Real-world cost examples:**

| Query | Songs | Duration | Cost (Free tier) |
|---|---|---|---|
| "Bohemian Rhapsody" (search) | 3 | ~11s | ~$0.03 |
| Artist: Eminem (top 50 songs) | 50 | ~78s | ~$0.35 |
| 2 song URLs with lyrics | 2 | ~15s | ~$0.02 |

With Apify's **free plan** ($5/month credit), you can scrape approximately **700 songs per month** at no cost.

### How to scrape Genius songs and lyrics

1. Go to the [Genius Scraper](https://apify.com/automation-lab/genius-scraper) page on Apify Store.
2. Click **Try for free** to open the actor in Apify Console.
3. Choose your scraping mode:
   - **Search**: Enter song titles, artist names, or lyrics in the "Search queries" field
   - **Artist**: Paste Genius artist URLs (e.g., `https://genius.com/artists/Queen`)
   - **Song URLs**: Paste direct song page URLs for specific lyrics extraction
4. Set **Max songs** to control how many results to extract (start small!).
5. Toggle **Include lyrics** on/off depending on your needs.
6. Click **Start** and wait for the run to finish.
7. Download results in JSON, CSV, or Excel from the **Dataset** tab.

**Example input for search:**
```json
{
    "searchQueries": ["Kendrick Lamar", "Taylor Swift Midnights"],
    "maxSongs": 20,
    "includeLyrics": true
}
````

**Example input for artist scraping:**

```json
{
    "artistUrls": [
        "https://genius.com/artists/Drake",
        "https://genius.com/artists/Beyonce"
    ],
    "maxSongs": 100,
    "includeLyrics": true
}
```

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | string\[] | `[]` | Song titles, artist names, or lyrics to search |
| `artistUrls` | string\[] | `[]` | Genius artist page URLs to scrape discographies |
| `songUrls` | string\[] | `[]` | Direct Genius song page URLs |
| `maxSongs` | integer | `50` | Max songs per search query or artist |
| `includeLyrics` | boolean | `true` | Whether to extract full lyrics text |

You must provide at least one of: `searchQueries`, `artistUrls`, or `songUrls`.

### Output example

```json
{
    "id": 1063,
    "title": "Bohemian Rhapsody",
    "artistName": "Queen",
    "artistId": 563,
    "artistUrl": "https://genius.com/artists/Queen",
    "artistImageUrl": "https://images.genius.com/3bc047e8b3c654ed28aedc69f93f8663.1000x1000x1.jpg",
    "albumName": "Studio Collection",
    "albumUrl": "https://genius.com/albums/Queen/Studio-collection",
    "albumCoverUrl": "https://images.genius.com/225103ef88cca1bc85c804a1ded937a5.597x597x1.jpg",
    "releaseDate": "1975-10-31",
    "url": "https://genius.com/Queen-bohemian-rhapsody-lyrics",
    "thumbnailUrl": "https://images.genius.com/718de9d1fbcaae9f3c9b1bf483bfa8f1.300x300x1.png",
    "imageUrl": "https://images.genius.com/718de9d1fbcaae9f3c9b1bf483bfa8f1.1000x1000x1.png",
    "pageviews": 11020679,
    "lyrics": "[Intro]\nIs this the real life? Is this just fantasy?\nCaught in a landslide, no escape from reality\n...",
    "language": "en",
    "description": "Widely considered to be one of the greatest songs of all time...",
    "spotifyUrl": "https://open.spotify.com/track/7tFiyTwD0nx5a1eklYtX2J",
    "youtubeUrl": "https://www.youtube.com/watch?v=fJ9rUzIMcZQ",
    "appleMusicUrl": "https://music.apple.com/song/932648449",
    "writerNames": ["Freddie Mercury"],
    "producerNames": ["Roy Thomas Baker", "Queen"],
    "featuredArtistNames": [],
    "annotationCount": 33,
    "isExplicit": false,
    "recordingLocation": "Rockfield Studios, Wye Valley, Monmouthshire, Wales, United Kingdom"
}
```

### Tips for best results

- **Start small** — use `maxSongs: 10` for your first run to verify the data matches your needs
- **Search mode is fastest** — returns 3-5 top matches per query, great for targeted extraction
- **Artist mode for completeness** — scrapes the full discography sorted by popularity
- **Disable lyrics for speed** — set `includeLyrics: false` if you only need metadata (2x faster)
- **Combine modes** — use search queries AND artist URLs in the same run
- **Schedule weekly runs** — track new releases by scheduling artist scrapes
- **Use song URLs for precision** — paste exact Genius URLs when you know which songs you need

### Integrations

Connect Genius Scraper to your existing workflows:

- **Genius Scraper → Google Sheets** — build a live music database with lyrics and metadata that updates automatically on a schedule
- **Genius Scraper → Slack/Discord** — get notified when new songs are added to an artist's discography
- **Genius Scraper → Make/Zapier** — trigger NLP analysis or translation workflows when new lyrics are scraped
- **Genius Scraper → PostgreSQL/BigQuery** — feed structured music data into your analytics warehouse
- **Scheduled runs** — monitor artist discographies weekly for new releases
- **Webhooks** — process lyrics in real-time as they're extracted

### API Usage

#### Node.js

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('automation-lab/genius-scraper').call({
    searchQueries: ['Kendrick Lamar'],
    maxSongs: 20,
    includeLyrics: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_API_TOKEN')

run = client.actor('automation-lab/genius-scraper').call(run_input={
    'searchQueries': ['Kendrick Lamar'],
    'maxSongs': 20,
    'includeLyrics': True,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~genius-scraper/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQueries": ["Kendrick Lamar"],
    "maxSongs": 20,
    "includeLyrics": true
  }'
```

### Use with AI agents via MCP

Genius Scraper is available as a tool for AI assistants that support the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp).

Add the Apify MCP server to your AI client — this gives you access to all Apify actors, including this one:

#### Setup for Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/genius-scraper"
```

#### Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

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

Your AI assistant will use OAuth to authenticate with your Apify account on first use.

#### Example prompts

Once connected, try asking your AI assistant:

- "Use automation-lab/genius-scraper to get all lyrics by Radiohead and analyze the most common themes"
- "Search Genius for songs about climate change and export the lyrics to a spreadsheet"
- "Scrape the top 50 songs by Taylor Swift and list which producers appear most frequently"

Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).

### Legality

Genius Scraper accesses only **publicly available data** on Genius.com — the same information any visitor can see in their browser. The scraper does not bypass any authentication, paywalls, or access restrictions.

Web scraping of public data is generally legal based on the 2022 US appeals court ruling in *hiQ Labs v. LinkedIn*, which confirmed that scraping publicly accessible data does not violate the Computer Fraud and Abuse Act (CFAA).

However, you should:

- Review Genius's [Terms of Service](https://genius.com/static/terms) before scraping
- Comply with GDPR and local data protection laws when processing personal data
- Use the data responsibly and respect intellectual property rights for lyrics content
- Avoid excessive request rates that could impact the website's performance

### FAQ

**How fast is Genius Scraper?**
A search query typically returns results in 10-15 seconds. Scraping 50 songs from an artist takes about 60 seconds. With lyrics extraction disabled, runs are roughly 2x faster since it skips fetching individual song pages.

**How much does it cost?**
With pay-per-event pricing, you pay approximately $0.003 per song (Starter plan). The free Apify plan ($5/month credit) gives you about 1,400 songs per month at no cost.

**Does it extract full lyrics?**
Yes, when `includeLyrics` is enabled, the scraper extracts the complete lyrics text from each song page. Lyrics are returned as plain text with section markers (e.g., \[Verse 1], \[Chorus]).

**Why are some lyrics null?**
Some songs on Genius are instrumental (no lyrics), unreleased, or have incomplete lyric entries. The `lyrics` field will be `null` in these cases. The metadata (title, artist, album, etc.) is still extracted from the API.

**Why are search results limited?**
Genius's search API returns the top matches per query. For comprehensive results, use artist mode with `artistUrls` to get the full discography, or provide multiple specific search queries.

**Can I scrape lyrics in other languages?**
Yes. Genius hosts lyrics in many languages. The `language` field in the output indicates the song's language. Search queries work in any language supported by Genius.

### Related Music and Media Scrapers

- [Spotify Scraper](https://apify.com/automation-lab/spotify-scraper) — extract playlists, tracks, and artist data from Spotify
- [YouTube Scraper](https://apify.com/automation-lab/youtube-scraper) — scrape video metadata, comments, and channel data
- [YouTube Transcript](https://apify.com/automation-lab/youtube-transcript) — extract video transcripts and subtitles
- [Apple App Store Scraper](https://apify.com/automation-lab/apple-app-store-scraper) — scrape app reviews and ratings
- [iTunes Scraper](https://apify.com/automation-lab/itunes-scraper) — extract music, podcast, and app data from iTunes
- [Podcast Scraper](https://apify.com/automation-lab/podcast-scraper) — scrape podcast episodes and metadata
- [MusicBrainz Scraper](https://apify.com/automation-lab/musicbrainz-scraper) — extract music metadata from MusicBrainz

# Actor input Schema

## `searchQueries` (type: `array`):

Enter song titles, artist names, or lyrics to search for on Genius. Each query returns matching songs with metadata and lyrics.

## `artistUrls` (type: `array`):

Add Genius artist page URLs to scrape their full discography. Example: https://genius.com/artists/Queen

## `songUrls` (type: `array`):

Add direct Genius song URLs to extract full lyrics and metadata. Example: https://genius.com/Queen-bohemian-rhapsody-lyrics

## `maxSongs` (type: `integer`):

Set the maximum number of songs to extract per search query or artist. Lower values = faster and cheaper runs.

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

Extract full song lyrics from each song page. Disabling this makes runs faster since it skips fetching individual song pages.

## Actor input object example

```json
{
  "searchQueries": [
    "Bohemian Rhapsody"
  ],
  "artistUrls": [],
  "songUrls": [],
  "maxSongs": 5,
  "includeLyrics": true
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchQueries": [
        "Bohemian Rhapsody"
    ],
    "artistUrls": [],
    "songUrls": [],
    "maxSongs": 5,
    "includeLyrics": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/genius-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 = {
    "searchQueries": ["Bohemian Rhapsody"],
    "artistUrls": [],
    "songUrls": [],
    "maxSongs": 5,
    "includeLyrics": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/genius-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 '{
  "searchQueries": [
    "Bohemian Rhapsody"
  ],
  "artistUrls": [],
  "songUrls": [],
  "maxSongs": 5,
  "includeLyrics": true
}' |
apify call automation-lab/genius-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Genius Scraper",
        "description": "Extract song lyrics, metadata, and artist data from Genius.com. Get titles, full lyrics text, release dates, Spotify/YouTube/Apple Music links, writer and producer credits, and pageview stats. Search songs, scrape artist discographies, or target specific URLs. Export to JSON, CSV, or Excel.",
        "version": "0.1",
        "x-build-id": "DBDO4WJsr0NWPdVgt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~genius-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-genius-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~genius-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-genius-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~genius-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-genius-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": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Enter song titles, artist names, or lyrics to search for on Genius. Each query returns matching songs with metadata and lyrics.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "artistUrls": {
                        "title": "Artist URLs",
                        "type": "array",
                        "description": "Add Genius artist page URLs to scrape their full discography. Example: https://genius.com/artists/Queen",
                        "items": {
                            "type": "string"
                        }
                    },
                    "songUrls": {
                        "title": "Song URLs",
                        "type": "array",
                        "description": "Add direct Genius song URLs to extract full lyrics and metadata. Example: https://genius.com/Queen-bohemian-rhapsody-lyrics",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxSongs": {
                        "title": "Max songs",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Set the maximum number of songs to extract per search query or artist. Lower values = faster and cheaper runs.",
                        "default": 50
                    },
                    "includeLyrics": {
                        "title": "Include lyrics",
                        "type": "boolean",
                        "description": "Extract full song lyrics from each song page. Disabling this makes runs faster since it skips fetching individual song pages.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
