# Genius Lyrics Scraper (`solidcode/genius-lyrics-scraper`) Actor

\[💰 $2.5 / 1K] Extract song lyrics, metadata, credits, streaming links, and artist profiles from Genius. Search by keyword or paste artist and song URLs.

- **URL**: https://apify.com/solidcode/genius-lyrics-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 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.

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 Lyrics Scraper

Pull full song lyrics, rich metadata, songwriting credits, and artist profiles from Genius at scale — every track comes with plain-text lyrics, page-view and annotation counts, album art, and direct Spotify, YouTube, SoundCloud, and Apple Music links. Built for ML and NLP researchers, music data analysts, journalists, and app developers who need a clean, structured lyrics dataset without parsing Genius song pages one at a time.

### Why This Scraper?

- **Full plain-text lyrics on every song row** — the complete lyrics for each track, cleaned and line-broken, parsed straight from the song page (instrumentals and incomplete entries return `null` instead of garbage).
- **Complete songwriting credits** — separate writer, producer, and featured-artist name arrays per track, so you can build credit graphs and royalty-style attribution datasets.
- **Streaming links to four platforms per track** — Spotify, YouTube, SoundCloud, and Apple Music URLs resolved on every song, ready to join against your own catalog.
- **Engagement signals built in** — page-view counts and annotation counts per song let you rank tracks by popularity without a second data source.
- **Three ways to feed it, mixed freely** — keyword search, artist-page URLs for a full discography, and direct song URLs all in one run.
- **Up to 1,000 songs per source** — pull an artist's deep catalog (sorted by popularity) or a wide keyword sweep in a single invocation, with smooth pagination and no duplicate rows within a source.
- **Standalone artist profiles** — opt in to get follower count, Genius IQ, verification status, alternate names, biography, and Instagram / Twitter / Facebook handles as their own row.
- **Filter to one of 12 languages** — keep English-only, Spanish-only, or any single language, or leave it on "Any language" to capture multilingual catalogs whole.

### Use Cases

**NLP & ML Lyric Datasets**
- Assemble a labeled corpus of plain-text lyrics for language-model fine-tuning
- Build sentiment, topic, or genre classifiers on real song text
- Train lyric-generation models on a single artist's complete catalog

**Music Market Research**
- Rank an artist's catalog by page views to find their breakout tracks
- Compare annotation counts to gauge which songs drive the most listener discussion
- Track release dates and explicit flags across a label's roster

**Journalism & Editorial**
- Pull verified songwriting and production credits for music reporting
- Quote lyrics with the canonical Genius source URL attached
- Build "who-produced-what" features from producer credit arrays

**App & Playlist Development**
- Power lyric-display features with clean, line-broken text
- Cross-link Genius tracks to Spotify, Apple Music, YouTube, and SoundCloud IDs
- Surface album art and song thumbnails in your own UI

**Academic & Cultural Research**
- Study lyrical themes across decades using release-date metadata
- Analyze featured-artist collaboration networks at scale
- Map an artist's social-media reach via profile follower counts

### Getting Started

#### Single Keyword Search

The simplest run — one search, the top 50 matching songs with lyrics:

```json
{
    "searchQueries": ["HUMBLE Kendrick Lamar"],
    "maxResults": 50
}
````

#### Full Artist Discography

Paste an artist-page URL to pull their catalog, ranked by popularity, capped at 200 songs:

```json
{
    "artistUrls": ["https://genius.com/artists/Drake"],
    "maxResults": 200,
    "includeArtistProfile": true
}
```

#### Multi-Source with Language Filter

Mix searches, artist pages, and direct song URLs — keep Spanish-language tracks only, and skip lyrics for a faster, lighter run:

```json
{
    "searchQueries": ["bad bunny"],
    "artistUrls": ["https://genius.com/artists/Rosalia"],
    "songUrls": ["https://genius.com/Kendrick-lamar-humble-lyrics"],
    "language": "es",
    "includeLyrics": false,
    "includeArtistProfile": true,
    "maxResults": 100
}
```

### Input Reference

#### Sources

Pick any combination — at least one is needed. Leave them all empty to run a small example search.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | string\[] | `["HUMBLE Kendrick Lamar"]` | Song titles, artist names, or lyric fragments to search on Genius. Each query runs independently and returns matching songs. |
| `artistUrls` | string\[] | `[]` | Genius artist-page URLs (e.g. `https://genius.com/artists/Drake`) to pull a full discography, up to the limit below. |
| `songUrls` | string\[] | `[]` | Direct Genius song-page URLs (e.g. `https://genius.com/Kendrick-lamar-humble-lyrics`). Each URL produces one song row. |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `50` | Maximum songs per search query or per artist. Set to `0` for all available songs. Hard upper bound is 1,000 per source. |

#### What to Extract

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeLyrics` | boolean | `true` | Extract full plain-text lyrics for every song. Turn off for a faster, smaller run that returns metadata, credits, and links only (roughly twice as fast). |
| `includeArtistProfile` | boolean | `false` | When you provide an artist URL or search for an artist, also emit a standalone artist-profile row with followers, verified status, biography, and social handles. |

#### Localization

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `language` | select | `Any language` | Keep songs only in a specific language. Options: Any language, English, Spanish, French, German, Italian, Portuguese, Dutch, Russian, Japanese, Korean, Chinese (Simplified). Picking a specific language drops songs detected in other languages. |

### Output

Every row carries a `recordType` field — `song` or `artist` — so you can filter the two cleanly in one dataset.

#### Song (`recordType: "song"`)

```json
{
    "recordType": "song",
    "id": 3039923,
    "title": "HUMBLE.",
    "url": "https://genius.com/Kendrick-lamar-humble-lyrics",
    "language": "en",
    "explicit": true,
    "releaseDate": "2017-03-30",
    "pageviews": 4821334,
    "annotationCount": 87,
    "thumbnailUrl": "https://images.genius.com/thumb.300x300.jpg",
    "imageUrl": "https://images.genius.com/songart.1000x1000.jpg",
    "lyrics": "[Intro]\nNobody pray for me\nIt's been that day for me\n...",
    "description": "\"HUMBLE.\" was the lead single from Kendrick Lamar's fourth studio album...",
    "artistName": "Kendrick Lamar",
    "artistId": 1421,
    "artistUrl": "https://genius.com/artists/Kendrick-lamar",
    "artistImageUrl": "https://images.genius.com/artist.jpg",
    "albumName": "DAMN.",
    "albumUrl": "https://genius.com/albums/Kendrick-lamar/Damn",
    "albumCoverUrl": "https://images.genius.com/albumcover.jpg",
    "writerNames": ["Kendrick Lamar", "Mike WiLL Made-It"],
    "producerNames": ["Mike WiLL Made-It"],
    "featuredArtistNames": [],
    "spotifyUrl": "https://open.spotify.com/track/7KXjTSCq5nL1LoYtL7XAwS",
    "youtubeUrl": "https://www.youtube.com/watch?v=tvTRZJ-4EyI",
    "soundcloudUrl": "https://soundcloud.com/kendrick-lamar-music/humble",
    "appleMusicUrl": "https://music.apple.com/us/album/_/1440881047",
    "recordingLocation": "Carnival Music Studio"
}
```

##### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"song"` |
| `id` | number | Genius song ID |
| `title` | string | Song title |
| `url` | string | Canonical Genius song-page URL |
| `language` | string | Detected ISO language code |
| `explicit` | boolean | Explicit-content flag |
| `releaseDate` | string | Release date (`YYYY`, `YYYY-MM`, or `YYYY-MM-DD`) |
| `lyrics` | string | Full plain-text lyrics (`null` for instrumentals or incomplete entries) |
| `description` | string | Song description / context text |
| `recordingLocation` | string | Recording studio or location, when listed |

##### Stats & Artwork

| Field | Type | Description |
|-------|------|-------------|
| `pageviews` | number | Total Genius page views for the song |
| `annotationCount` | number | Number of community annotations on the lyrics |
| `thumbnailUrl` | string | Small song-art image URL |
| `imageUrl` | string | Full-size song-art image URL |

##### Artist & Album

| Field | Type | Description |
|-------|------|-------------|
| `artistName` | string | Primary artist name |
| `artistId` | number | Genius artist ID |
| `artistUrl` | string | Genius artist-page URL |
| `artistImageUrl` | string | Primary artist image URL |
| `albumName` | string | Album name, when the song belongs to one |
| `albumUrl` | string | Genius album-page URL |
| `albumCoverUrl` | string | Album cover-art image URL |

##### Credits & Streaming Links

| Field | Type | Description |
|-------|------|-------------|
| `writerNames` | string\[] | Songwriter credits |
| `producerNames` | string\[] | Producer credits |
| `featuredArtistNames` | string\[] | Featured-artist credits |
| `spotifyUrl` | string | Spotify track URL, when available |
| `youtubeUrl` | string | YouTube video URL, when available |
| `soundcloudUrl` | string | SoundCloud track URL, when available |
| `appleMusicUrl` | string | Apple Music URL, when available |

#### Artist (`recordType: "artist"`)

Emitted only when `includeArtistProfile: true` for artist sources.

```json
{
    "recordType": "artist",
    "artistId": 1421,
    "name": "Kendrick Lamar",
    "url": "https://genius.com/artists/Kendrick-lamar",
    "imageUrl": "https://images.genius.com/artist.1000x1000.jpg",
    "alternateNames": ["K.Dot", "Kung Fu Kenny"],
    "followerCount": 41822,
    "isVerified": true,
    "iq": 21450,
    "description": "Kendrick Lamar Duckworth is a Pulitzer Prize-winning rapper from Compton, California...",
    "instagramName": "kendricklamar",
    "twitterName": "kendricklamar",
    "facebookName": "kendricklamar"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"artist"` |
| `artistId` | number | Genius artist ID |
| `name` | string | Artist display name |
| `url` | string | Genius artist-page URL |
| `imageUrl` | string | Artist avatar image URL |
| `alternateNames` | string\[] | Known aliases and alternate spellings |
| `followerCount` | number | Genius follower count |
| `isVerified` | boolean | Whether the artist account is verified on Genius |
| `iq` | number | Genius IQ score (community contribution metric) |
| `description` | string | Artist biography text |
| `instagramName` | string | Instagram handle |
| `twitterName` | string | Twitter / X handle |
| `facebookName` | string | Facebook handle |

### Tips for Best Results

- **Use artist URLs for complete discographies.** A `https://genius.com/artists/...` URL pulls the artist's whole catalog sorted by popularity — far more reliable than guessing search terms for every track.
- **Leave language on "Any language" for multilingual artists.** Picking a specific language drops every track detected in another tongue, so bilingual or crossover catalogs come back partial. Only set a language when you truly want one.
- **Turn off lyrics for metadata-only runs.** Setting `includeLyrics: false` roughly halves runtime and shrinks each row when you only need credits, stats, and streaming links.
- **Keep `maxResults` modest while testing.** Start at 25–50 to confirm the data shape, then raise it — popular artists can have well over 1,000 songs, so an uncapped run is large.
- **Add `includeArtistProfile` for one-row artist context.** It appears once per artist source as its own `artist` row, so it costs a single extra result while giving you followers, IQ, and social handles.
- **Filter by `recordType` downstream.** Songs and artist profiles land in the same dataset — split on `recordType` to route each into its own table.
- **Rank by `pageviews` for popularity, `annotationCount` for discussion.** They capture different signals: views measure reach, annotations measure how much listeners dissect the lyrics.

### Pricing

**$2.50 per 1,000 results** — flat pay-per-result, with lyrics, credits, streaming links, and engagement stats all bundled into every song row at no extra charge.

| Results | Estimated Cost |
|---------|----------------|
| 100 | $0.25 |
| 1,000 | $2.50 |
| 10,000 | $25.00 |
| 100,000 | $250.00 |

A "result" is any row in the output dataset — a song or an artist profile. No compute charges — you only pay per result returned.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate research, journalism, and data analysis. Lyrics and other content remain the property of their respective rights holders — users are responsible for complying with applicable copyright law and Genius's terms of service, including respecting content-usage and redistribution rules. Do not use extracted data for spam, harassment, or any illegal purpose.

# Actor input Schema

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

Song titles, artist names, or lyric fragments to search on Genius (e.g. 'HUMBLE Kendrick Lamar' or 'we all we got'). Each query runs independently and returns matching songs. Leave empty if you only want to use artist or song URLs.

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

Genius artist-page URLs to pull a full discography, e.g. 'https://genius.com/artists/Drake'. Every song on the artist's catalog is collected, up to the limit below.

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

Direct Genius song-page URLs for exact songs you already know, e.g. 'https://genius.com/Kendrick-lamar-humble-lyrics'. Each URL produces one song row.

## `maxResults` (type: `integer`):

How many songs to collect per search query or per artist. Set to 0 for all available songs. Recommended: 50-500 to keep runs fast and costs predictable. Hard upper bound is 1,000 per source.

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

Extract the full plain-text lyrics for every song. Turn this off for a faster, smaller run that returns metadata, credits, and links only (roughly twice as fast).

## `includeArtistProfile` (type: `boolean`):

When you provide an artist URL or search for an artist, also emit a standalone artist-profile row (recordType 'artist') with followers, verified status, biography, and social handles. Off by default to keep the dataset focused on songs.

## `language` (type: `string`):

Keep songs only in a specific language. Leave on 'Any language' (the default) to return every song regardless of language. Picking a specific language drops songs detected in other languages.

## Actor input object example

```json
{
  "searchQueries": [
    "HUMBLE Kendrick Lamar"
  ],
  "artistUrls": [],
  "songUrls": [],
  "maxResults": 50,
  "includeLyrics": true,
  "includeArtistProfile": false,
  "language": "any"
}
```

# Actor output Schema

## `songs` (type: `string`):

Table of song results with title, artist, album, release date, pageviews, lyrics, and links.

## `artists` (type: `string`):

Artist-profile rows with followers, verified status, IQ, bio, and social handles (only present when 'Include Artist Profile' is enabled).

# 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": [
        "HUMBLE Kendrick Lamar"
    ],
    "artistUrls": [],
    "songUrls": [],
    "maxResults": 50,
    "includeLyrics": true,
    "includeArtistProfile": false,
    "language": "any"
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/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 = {
    "searchQueries": ["HUMBLE Kendrick Lamar"],
    "artistUrls": [],
    "songUrls": [],
    "maxResults": 50,
    "includeLyrics": True,
    "includeArtistProfile": False,
    "language": "any",
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/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 '{
  "searchQueries": [
    "HUMBLE Kendrick Lamar"
  ],
  "artistUrls": [],
  "songUrls": [],
  "maxResults": 50,
  "includeLyrics": true,
  "includeArtistProfile": false,
  "language": "any"
}' |
apify call solidcode/genius-lyrics-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Genius Lyrics Scraper",
        "description": "[💰 $2.5 / 1K] Extract song lyrics, metadata, credits, streaming links, and artist profiles from Genius. Search by keyword or paste artist and song URLs.",
        "version": "1.0",
        "x-build-id": "nWZkaNcgyuCrKGU6M"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~genius-lyrics-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-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/solidcode~genius-lyrics-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-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/solidcode~genius-lyrics-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-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": {
                    "searchQueries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "Song titles, artist names, or lyric fragments to search on Genius (e.g. 'HUMBLE Kendrick Lamar' or 'we all we got'). Each query runs independently and returns matching songs. Leave empty if you only want to use artist or song URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "artistUrls": {
                        "title": "Artist URLs",
                        "type": "array",
                        "description": "Genius artist-page URLs to pull a full discography, e.g. 'https://genius.com/artists/Drake'. Every song on the artist's catalog is collected, up to the limit below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "songUrls": {
                        "title": "Song URLs",
                        "type": "array",
                        "description": "Direct Genius song-page URLs for exact songs you already know, e.g. 'https://genius.com/Kendrick-lamar-humble-lyrics'. Each URL produces one song row.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Maximum Songs per Source",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "How many songs to collect per search query or per artist. Set to 0 for all available songs. Recommended: 50-500 to keep runs fast and costs predictable. Hard upper bound is 1,000 per source.",
                        "default": 50
                    },
                    "includeLyrics": {
                        "title": "Include Lyrics",
                        "type": "boolean",
                        "description": "Extract the full plain-text lyrics for every song. Turn this off for a faster, smaller run that returns metadata, credits, and links only (roughly twice as fast).",
                        "default": true
                    },
                    "includeArtistProfile": {
                        "title": "Include Artist Profile",
                        "type": "boolean",
                        "description": "When you provide an artist URL or search for an artist, also emit a standalone artist-profile row (recordType 'artist') with followers, verified status, biography, and social handles. Off by default to keep the dataset focused on songs.",
                        "default": false
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "any",
                            "en",
                            "es",
                            "fr",
                            "de",
                            "it",
                            "pt",
                            "nl",
                            "ru",
                            "ja",
                            "ko",
                            "zh-CN"
                        ],
                        "type": "string",
                        "description": "Keep songs only in a specific language. Leave on 'Any language' (the default) to return every song regardless of language. Picking a specific language drops songs detected in other languages.",
                        "default": "any"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```