# Genius Scraper (`goat255/genius-scraper`) Actor

Scrape Genius song and artist metadata without a login. Search songs, artists, and albums by keyword, fetch full metadata for a song, or pull an artist profile plus their song catalog with pageviews and release dates. Metadata only.

- **URL**: https://apify.com/goat255/genius-scraper.md
- **Developed by:** [Goutam Soni](https://apify.com/goat255) (community)
- **Categories:** Social media, News, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event. 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

Extract public song and artist metadata from Genius with no login and no API key. Search by keyword, pull a single song's full metadata, or scrape an artist profile plus their entire song catalog (titles, primary and featured artists, release dates, pageviews, annotation counts, artwork, and more). This Genius scraper returns metadata only and never reads or stores song lyrics.

### What it does

- **Keyword search** across Genius. One query returns matching songs, artists, and albums together with titles, primary artist, release dates, public pageviews, and artwork.
- **Song metadata** from a Genius song link or numeric id. Returns title, primary artist, featured artists, release date, pageviews, annotation count, pyongs, hot flag, instrumental flag, and artwork.
- **Artist catalog** by artist name, link, or id. Returns an artist profile (follower count, bio, verification, social handles, artwork) plus that artist's songs, paginated all the way to your limit.
- **Automatic pagination.** The artist catalog walks page after page until it reaches the number of songs you asked for or the catalog runs out. No manual cursor handling.
- **Clean, normalized output.** Every row is a flat object with stable, importance-ordered columns. Missing values are explicit nulls, so your downstream code never breaks on a shape change.
- **Concurrent processing.** Multiple search terms, songs, and artists are processed in parallel for fast bulk runs.

### Use cases

- **Music market research.** Pull an artist's full catalog with pageviews and release dates to spot which tracks drive the most attention over time.
- **Catalog and metadata enrichment.** Match your own track list against Genius to fill in release dates, featured artists, primary artist ids, and canonical titles.
- **Trend and popularity monitoring.** Re-run on a schedule and track how pageviews and annotation counts move for songs or artists you follow.
- **Playlist and recommendation datasets.** Build a structured songs-and-artists dataset for a music app, newsletter, or recommendation model.
- **Artist discovery.** Search a genre keyword and collect the songs, artists, and albums that surface, with their public stats.

### Input

| Field | Type | Description |
|---|---|---|
| `searchQueries` | array of strings | Keywords to search. Each returns matching songs, artists, and albums with metadata. |
| `songUrls` | array of strings | Genius song links or numeric song ids to fetch full metadata for. |
| `artists` | array of strings | Artist names, Genius artist links, or numeric artist ids to pull a profile and catalog for. |
| `maxSongsPerArtist` | integer | Maximum songs returned per artist. Pagination is walked until this is reached or the catalog is exhausted. Default 100. |
| `includeArtistProfile` | boolean | When on, each artist also emits one profile row (name, follower count, bio, social handles) before its songs. Default true. |
| `artistSongsSort` | string | Sort order for an artist's songs: `popularity`, `release_date`, or `title`. Default `popularity`. |
| `concurrency` | integer | How many sources (queries, songs, artists) to process in parallel. Default 5. |
| `proxyConfig` | object | Optional proxy configuration. Residential proxy is used by default. |

#### Example input

```json
{
  "searchQueries": ["bohemian rhapsody"],
  "artists": ["Acme Band", "https://genius.com/artists/Acme-band"],
  "maxSongsPerArtist": 200,
  "includeArtistProfile": true,
  "artistSongsSort": "popularity"
}
````

### Output

Each result is pushed as one row to the dataset. A song row looks like this:

```json
{
  "type": "song",
  "id": 123456,
  "url": "https://example.com/example-song",
  "primaryArtist": "Acme Band",
  "primaryArtistId": 130,
  "pageviews": 10241931,
  "annotationCount": 49,
  "pyongsCount": 759,
  "hot": false,
  "instrumental": false,
  "title": "Example Song",
  "fullTitle": "Example Song by Acme Band (Ft. Example Guest)",
  "featuredArtists": ["Example Guest"],
  "thumbnail": "https://example.com/art-thumb.jpg",
  "songArtImageUrl": "https://example.com/art.jpg",
  "headerImageUrl": "https://example.com/header.jpg",
  "releaseDate": "2018-08-03",
  "releaseDateDisplay": "August 3, 2018"
}
```

Key fields:

- **`type`** distinguishes each row: `song`, `artist`, or `album`.
- **`pageviews`** is the public view count at scrape time, the best popularity signal.
- **`primaryArtist` / `primaryArtistId`** identify the main artist for joining across rows.
- **`releaseDate`** is normalized to `YYYY-MM-DD`; **`releaseDateDisplay`** keeps the human-readable form.
- **`featuredArtists`** is an array of names (empty when a track has no guests).

An **artist** row (emitted when `includeArtistProfile` is on) carries `name`, `followersCount`, `iq`, `isVerified`, `isMemeVerified`, `description` (bio text), `alternateNames`, `instagramName`, `twitterName`, `facebookName`, `imageUrl`, and `headerImageUrl`.

An **album** row carries `name`, `fullTitle`, `primaryArtist`, `coverArtUrl`, and `releaseDateDisplay`.

### FAQ

**Is it free? How is it priced?**
You pay per result. There is no per-run start fee. Each row pushed to the dataset is billed at a flat rate, so a search that returns 30 results costs the same whether it runs fast or slow.

**Do I need a Genius login, account, or API key?**
No. The actor reads only public metadata. You do not provide any credentials.

**Does it return song lyrics?**
No. This actor returns metadata only (titles, artists, dates, public stats, artwork). It never reads or stores lyrics.

**How many songs can I get per artist?**
As many as the artist has. Set `maxSongsPerArtist` to your target (for example 500) and pagination is walked across as many pages as needed until that number is reached or the catalog is exhausted.

**How fast is it?**
Multiple sources run in parallel. A typical artist catalog of a few hundred songs completes in well under a minute. Raise `concurrency` to process more queries, songs, and artists at once.

**What input formats are accepted for songs and artists?**
Songs accept a Genius song link or a numeric song id. Artists accept an artist name, a Genius artist link, or a numeric artist id. The actor resolves each to the right record automatically.

**Why is a field null for some rows?**
Each row is a stable shape. When Genius does not publish a value for a given item (for example a missing release date or a track with no featured artists), that field is returned as `null` or an empty array rather than omitted, so your downstream parsing stays consistent.

# Actor input Schema

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

Keywords to search Genius. Returns matching songs, artists, and albums with their metadata. Example: drake, taylor swift, bohemian rhapsody.

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

Specific songs to fetch full metadata for. Accepts a Genius song link or a numeric song id. Example: https://genius.com/example-artist-example-song-lyrics.

## `artists` (type: `array`):

Artists to pull a profile and song catalog for. Accepts an artist name, a Genius artist link, or a numeric artist id. Example: Acme Band, https://genius.com/artists/Acme-band.

## `maxSongsPerArtist` (type: `integer`):

Cap on how many songs are returned per artist. Pagination is walked across multiple pages until this is reached or the catalog is exhausted.

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

When on, each artist also emits one profile record (name, follower count, social handles) before its songs.

## `artistSongsSort` (type: `string`):

Sort order for an artist's songs. By popularity, release date, or title.

## `concurrency` (type: `integer`):

How many sources to process in parallel.

## `proxyConfig` (type: `object`):

Optional proxy. The public read endpoints do not require a proxy, but you may route through one if you wish.

## Actor input object example

```json
{
  "searchQueries": [
    "drake"
  ],
  "songUrls": [],
  "artists": [],
  "maxSongsPerArtist": 100,
  "includeArtistProfile": true,
  "artistSongsSort": "popularity",
  "concurrency": 5,
  "proxyConfig": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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": [
        "drake"
    ],
    "songUrls": [],
    "artists": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("goat255/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": ["drake"],
    "songUrls": [],
    "artists": [],
}

# Run the Actor and wait for it to finish
run = client.actor("goat255/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": [
    "drake"
  ],
  "songUrls": [],
  "artists": []
}' |
apify call goat255/genius-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Genius Scraper",
        "description": "Scrape Genius song and artist metadata without a login. Search songs, artists, and albums by keyword, fetch full metadata for a song, or pull an artist profile plus their song catalog with pageviews and release dates. Metadata only.",
        "version": "0.1",
        "x-build-id": "MH9FLw0hELkFzi2Vz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/goat255~genius-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-goat255-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/goat255~genius-scraper/runs": {
            "post": {
                "operationId": "runs-sync-goat255-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/goat255~genius-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-goat255-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 (search mode)",
                        "type": "array",
                        "description": "Keywords to search Genius. Returns matching songs, artists, and albums with their metadata. Example: drake, taylor swift, bohemian rhapsody.",
                        "default": [
                            "drake"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "songUrls": {
                        "title": "Song URLs or IDs (song mode)",
                        "type": "array",
                        "description": "Specific songs to fetch full metadata for. Accepts a Genius song link or a numeric song id. Example: https://genius.com/example-artist-example-song-lyrics.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "artists": {
                        "title": "Artists (artist mode)",
                        "type": "array",
                        "description": "Artists to pull a profile and song catalog for. Accepts an artist name, a Genius artist link, or a numeric artist id. Example: Acme Band, https://genius.com/artists/Acme-band.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxSongsPerArtist": {
                        "title": "Max songs per artist",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Cap on how many songs are returned per artist. Pagination is walked across multiple pages until this is reached or the catalog is exhausted.",
                        "default": 100
                    },
                    "includeArtistProfile": {
                        "title": "Include an artist profile row",
                        "type": "boolean",
                        "description": "When on, each artist also emits one profile record (name, follower count, social handles) before its songs.",
                        "default": true
                    },
                    "artistSongsSort": {
                        "title": "Artist songs sort",
                        "enum": [
                            "popularity",
                            "release_date",
                            "title"
                        ],
                        "type": "string",
                        "description": "Sort order for an artist's songs. By popularity, release date, or title.",
                        "default": "popularity"
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many sources to process in parallel.",
                        "default": 5
                    },
                    "proxyConfig": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy. The public read endpoints do not require a proxy, but you may route through one if you wish.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
