# Genius Lyrics & Songs Scraper (`crawlerbros/genius-scraper`) Actor

Scrape song lyrics, artist info, and trending songs from Genius.com. Search songs/artists/albums, fetch lyrics by URL or ID, get artist top songs. No API key required.

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

## Pricing

from $3.00 / 1,000 results

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

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 & Songs Scraper

Scrape **Genius.com** — the world's biggest song lyrics and music-knowledge platform. Pull trending chart songs, full lyrics, artist profiles, album tracklists, editorial videos/articles, community user profiles, and crowd-sourced lyric annotations. No Genius API key or login required.

### What this actor does

- **Five modes:** `trending` (homepage/genre charts), `search` (songs, artists, albums, videos, articles, users, or lyric-content search), `artistSongs` (an artist's top tracks), `byUrl`, and `byId` (fetch specific songs directly)
- **Full lyrics** for every song, plus album, genre tags, producer/writer credits, streaming links (YouTube, Spotify, SoundCloud, Apple Music), and release date
- **Artist profiles** with bio, follower count, and social links (Twitter/X, Instagram, Facebook, TikTok, Snapchat, Spotify, SoundCloud, Apple Music, YouTube, website, and more)
- **Crowd-sourced lyric annotations** — the community explanations shown in Genius's highlighted-lyric popups
- **Empty fields are omitted** from every record — you'll never see `null` or empty-string values in the output

### Output per record

Every record carries `recordType` (one of `song`, `artist`, `album`, `video`, `article`, `user`) and `scrapedAt` (ISO timestamp). Fields not resolvable for a given record are simply omitted.

#### Song records (`trending`, `search` with `searchType=song`/`lyric`, `artistSongs`, `byUrl`, `byId`)

- `songId`, `title`, `artistName`, `artistId`
- `releaseDate`, `imageUrl`, `songUrl`
- `lyrics` — full lyrics text (when `includeLyrics` is enabled)
- `pageViews`, `annotationCount`, `pyongsCount` (Genius's own like/upvote count)
- `hot`, `instrumental`, `lyricsState` (`complete`, `incomplete`, `unreleased`, ...)
- `featuredArtists[]`
- `album` — `{ name, url }`
- `genreTags[]`, `producerArtists[]`, `writerArtists[]`
- `youtubeUrl`, `spotifyUrl`, `soundcloudUrl`, `appleMusicUrl`
- `language`, `explicit`, `description`
- `annotations[]` — `{ fragment, annotationText, authorName, votesTotal, annotationUrl }` (when `includeAnnotations` is enabled and the song has community annotations)

#### Artist records (`search` with `searchType=artist`, or the bonus profile record in `artistSongs`)

- `artistId`, `artistName`, `slug`, `artistUrl`
- `imageUrl`, `headerImageUrl`
- `verified`, `iq` (Genius reputation score)
- `followersCount`, `bio`, `alternateNames[]`, `translationArtist`
- `twitterUrl`, `instagramUrl`, `facebookUrl`, `tiktokUrl`, `snapchatUrl`
- `spotifyUrl`, `soundcloudUrl`, `appleMusicUrl`, `youtubeUrl`, `amazonMusicUrl`, `shazamUrl`, `tidalUrl`, `websiteUrl`

#### Album records (`search` with `searchType=album`)

- `albumId`, `albumName`, `artistName`, `artistId`
- `coverUrl`, `headerImageUrl`, `albumUrl`, `releaseDate`
- `description`, `language`, `albumType`
- `pyongsCount`, `commentCount`, `trackCount`
- `tracklist[]` — `{ position, title, songUrl }`

#### Video records (`search` with `searchType=video`)

- `videoId`, `title`, `videoUrl`, `articleUrl`
- `description`, `posterUrl`, `durationSeconds`, `viewCount`
- `publishedAt`, `authorName`

#### Article records (`search` with `searchType=article`)

- `articleId`, `title`, `articleUrl`, `description`
- `articleType`, `previewImageUrl`
- `pyongsCount`, `votesTotal`, `publishedAt`, `authorName`

#### User records (`search` with `searchType=user`)

- `userId`, `username`, `displayName`, `userUrl`
- `aboutMe`, `role`, `avatarUrl`
- `iq`, `verified`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | select | `trending` | `trending` / `search` / `artistSongs` / `byUrl` / `byId` |
| `chartGenre` | select | `all` | Genre filter for trending charts: `all`, `pop`, `rap`, `electronic`, `rock`, `country`, `rb` (mode=trending) |
| `timePeriod` | select | `day` | Time window for trending charts: `day`, `week`, `month`, `all_time` (mode=trending) |
| `searchQuery` | string | – | Search term (mode=search) |
| `searchType` | select | `song` | `song` / `artist` / `album` / `video` / `article` / `user` / `lyric` (find songs by lyric content) (mode=search) |
| `artistName` | string | – | Artist name to fetch top songs for (mode=artistSongs) |
| `artistSongsSort` | select | `popularity` | `popularity` / `title` / `release_date` (mode=artistSongs) |
| `songUrls` | array | `[]` | Genius song page URLs to fetch (mode=byUrl) |
| `songIds` | array | `[]` | Genius numeric song IDs to fetch (mode=byId) |
| `includeLyrics` | boolean | `true` | Fetch full lyrics text for each song |
| `includeArtistDetails` | boolean | `true` | Fetch full artist profile — bio, followers, social links (mode=search with searchType=artist, and mode=artistSongs) |
| `includeAlbumDetails` | boolean | `true` | Fetch full album details and tracklist (mode=search with searchType=album) |
| `includeAnnotations` | boolean | `false` | Fetch crowd-sourced lyric-fragment annotations for song records (any mode) |
| `maxItems` | integer | `20` | Maximum number of records to return (1–500) |
| `proxy` | object | Residential | Apify Proxy configuration (residential required — see FAQ) |

#### Example: today's trending pop songs

```json
{
  "mode": "trending",
  "chartGenre": "pop",
  "timePeriod": "day",
  "maxItems": 25
}
```

#### Example: search for songs with full lyrics

```json
{
  "mode": "search",
  "searchQuery": "bohemian rhapsody",
  "searchType": "song",
  "includeLyrics": true,
  "maxItems": 10
}
```

#### Example: an artist's top tracks with profile

```json
{
  "mode": "artistSongs",
  "artistName": "queen",
  "artistSongsSort": "popularity",
  "includeArtistDetails": true,
  "maxItems": 20
}
```

#### Example: fetch specific songs by URL with annotations

```json
{
  "mode": "byUrl",
  "songUrls": ["https://genius.com/Queen-bohemian-rhapsody-lyrics"],
  "includeLyrics": true,
  "includeAnnotations": true
}
```

### Use cases

- **Lyrics apps & karaoke tools** — bulk-import full lyrics with structured metadata
- **Music trend tracking** — monitor daily/weekly/monthly genre charts for A\&R or playlist curation
- **Artist research** — pull discographies, follower counts, and social links for outreach or fan analytics
- **NLP & text mining** — build lyric datasets for sentiment analysis, genre classification, or generative models
- **Music journalism** — surface editorial videos/articles and crowd annotations for a song or artist
- **Recommendation engines** — feed genre tags, producer/writer credits, and album data into a music recommender

### FAQ

**Do I need a Genius API key or account?**
No. This actor works without any Genius account, login, or API key.

**Are lyrics included by default?**
Yes, `includeLyrics` defaults to `true`. Set it to `false` to skip lyrics and return metadata only, which is faster.

**How do I find a Genius song ID?**
Run `mode=search` first and read the `songId` field from the results, or open a song's page on Genius and note the numeric ID shown in its `genius.com/songs/{id}` link.

**Why are some songs missing lyrics?**
Genius marks certain tracks as instrumental, or the lyrics haven't been transcribed by the community yet — `lyricsState` on the song record reflects this.

**What's the difference between `searchType=song` and `searchType=lyric`?**
`song` matches by title or artist name; `lyric` matches songs by the actual words in the lyrics, which is useful when you only remember a line and not the title.

**How many results can I get for albums, videos, articles, users, or lyric search?**
Those search types are capped at 5 results per run by Genius's own search system, regardless of `maxItems`. Song search and other modes are not capped this way.

**Does `artistSongs` mode include the artist's profile?**
Yes — when `includeArtistDetails` is `true` (default), one extra artist profile record is added alongside the song records; it does not count against `maxItems`, which governs the song count.

**Why is residential proxy required?**
Genius.com blocks Apify's default/datacenter IP ranges with an HTTP 403 error. A residential proxy is pre-configured as the default input so the actor works reliably out of the box.

**Is this actor affiliated with Genius?**
No, this is an independent third-party actor that reads publicly accessible Genius.com pages and endpoints. It is not affiliated with or endorsed by Genius.

# Actor input Schema

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

What to scrape from Genius.

## `chartGenre` (type: `string`):

Genre filter for the trending charts (mode=trending).

## `timePeriod` (type: `string`):

Time window for the trending charts (mode=trending).

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

Search term (mode=search).

## `searchType` (type: `string`):

Type of entity to search for (mode=search).

## `artistName` (type: `string`):

Artist name to fetch top songs for (mode=artistSongs).

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

Sort order for the artist's songs (mode=artistSongs).

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

Genius song page URLs to fetch (mode=byUrl). e.g. https://genius.com/Queen-bohemian-rhapsody-lyrics

## `songIds` (type: `array`):

Genius numeric song IDs (mode=byId).

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

Fetch full song lyrics text (requires an additional HTTP request per song).

## `includeArtistDetails` (type: `boolean`):

Fetch full artist profile (bio, follower count, social links) from the artist's own page. Applies to mode=search with searchType=artist (enriches each artist result) and mode=artistSongs (adds one bonus artist profile record alongside the songs). Requires an additional HTTP request per artist.

## `includeAlbumDetails` (type: `boolean`):

Fetch full album details (description, track listing, pyongs/comment counts) from the album's own Genius page. Applies to mode=search with searchType=album. Requires an additional HTTP request per album.

## `includeAnnotations` (type: `boolean`):

Fetch crowd-sourced annotations that explain specific lyric fragments (the same explanations shown in the highlighted-lyric popups on a Genius song page), attached as an `annotations` array on each song record. Applies to song records only (any mode). Requires an additional HTTP request per song, so it's off by default.

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

Maximum number of records to return.

## `proxy` (type: `object`):

Apify proxy. Genius.com blocks Apify's default/datacenter IPs with HTTP 403 — Residential proxy is required for reliable results.

## Actor input object example

```json
{
  "mode": "trending",
  "chartGenre": "all",
  "timePeriod": "day",
  "searchQuery": "bohemian rhapsody",
  "searchType": "song",
  "artistName": "queen",
  "artistSongsSort": "popularity",
  "songUrls": [],
  "songIds": [],
  "includeLyrics": true,
  "includeArtistDetails": true,
  "includeAlbumDetails": true,
  "includeAnnotations": false,
  "maxItems": 20,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Dataset containing all scraped Genius song and artist records.

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "mode": "trending",
    "chartGenre": "all",
    "timePeriod": "day",
    "searchQuery": "bohemian rhapsody",
    "searchType": "song",
    "artistName": "queen",
    "artistSongsSort": "popularity",
    "songUrls": [],
    "songIds": [],
    "includeLyrics": true,
    "includeArtistDetails": true,
    "includeAlbumDetails": true,
    "includeAnnotations": false,
    "maxItems": 20,
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/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 = {
    "mode": "trending",
    "chartGenre": "all",
    "timePeriod": "day",
    "searchQuery": "bohemian rhapsody",
    "searchType": "song",
    "artistName": "queen",
    "artistSongsSort": "popularity",
    "songUrls": [],
    "songIds": [],
    "includeLyrics": True,
    "includeArtistDetails": True,
    "includeAlbumDetails": True,
    "includeAnnotations": False,
    "maxItems": 20,
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/genius-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "trending",
  "chartGenre": "all",
  "timePeriod": "day",
  "searchQuery": "bohemian rhapsody",
  "searchType": "song",
  "artistName": "queen",
  "artistSongsSort": "popularity",
  "songUrls": [],
  "songIds": [],
  "includeLyrics": true,
  "includeArtistDetails": true,
  "includeAlbumDetails": true,
  "includeAnnotations": false,
  "maxItems": 20,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call crawlerbros/genius-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawlerbros/genius-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/addG7h8q5lSQLMCI4/builds/7RI2pcsGACuJexD2w/openapi.json