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

Search and scrape song metadata and lyrics from Genius by artist, song title, or keyword. Returns each song as a flat row with title, primary artist, album, release date, page URL, and optional full lyrics.

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

## Pricing

from $19.00 / 1,000 results

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

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### Genius Lyrics Scraper

**Scrape song metadata and lyrics from Genius by artist, song title, or keyword, up to a million songs per run.** Each result includes the song title, primary artist, album, release date, page URL, and optional full lyrics. Export to CSV, JSON, Excel, or XML.

Genius is the web's largest library of song lyrics and musical knowledge, but manually copying data from its pages is slow and error-prone. This Actor searches Genius directly for any artist, song, or keyword you provide and returns structured results in a consistent format. No API key, no browser automation to manage, a flat dataset ready for analysis.

| Who uses it | What they scrape Genius for |
|---|---|
| Music data analysts | Building datasets of song metadata and lyrics for trend analysis and genre classification. |
| Linguists and NLP researchers | Collecting large corpora of song lyrics for natural language processing and sentiment analysis. |
| Music bloggers and journalists | Gathering discography data and lyrical themes for artist profiles and reviews. |
| App developers | Populating music discovery or trivia apps with structured song information. |

### What it does

This Actor searches Genius by artist name, song title, or keyword and returns each matching song as a flat row with metadata and optional full lyrics.

- 🔍 **Keyword search:** Enter any artist name, song title, or combination of keywords to find matching songs on Genius.
- 📝 **Optional full lyrics:** Toggle lyrics collection on when you need the complete song text, or leave it off for faster metadata-only runs.
- 📊 **Flat row output:** Every song returns as one row with a fixed schema, ready for spreadsheets, databases, or downstream processing.
- ⚡ **High throughput:** Collect up to a million songs per run, constrained only by the maxItems you set.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with Genius data

**📈 Build a lyrics corpus for NLP.**

A computational linguist searches for an artist's full discography with lyrics enabled to train a text generation model on lyrical style and structure.

**🎧 Analyze an artist's discography.**

A music journalist enters an artist name to collect every song, album, and release date for a career retrospective article.

**📊 Track lyrical themes across genres.**

A data analyst runs multiple keyword searches for genre-specific terms and compares the resulting song metadata to identify thematic patterns.

**🎵 Populate a music trivia app.**

An indie developer scrapes song titles and primary artists for a set of popular keywords to seed a song-guessing game with fresh content.

### Why choose this scraper

| | What you get |
|---|---|
| **No API key required** | Start scraping immediately without registering an application or managing OAuth tokens. |
| **Structured output** | Every song arrives as a flat row with consistent fields, no nested JSON to flatten. |
| **Lyrics on demand** | Fetch full lyrics only when you need them, saving time and requests on metadata-only runs. |
| **Simple input** | One search field and one number control the entire run, no complex configuration needed. |

### How it compares

This Actor focuses on fast, straightforward search-based scraping of song metadata and optional lyrics from Genius, while other actors add translation, streaming links, or bulk keyword processing.

| Feature | ParseForge | Genius Lyrics Scraper & Translator | Genius Song Lyrics Scraper | Genius Scraper All-in-One |
|---|---|---|---|---|
| Search by artist or song keyword | Yes | Yes | Yes | Yes |
| Optional full lyrics extraction | Yes | Yes | Yes | Yes |
| AI-powered lyrics translation | Not listed | Yes | Not listed | Not listed |
| Streaming service links | Not listed | Not listed | Yes | Not listed |
| Bulk keyword processing | Not listed | Not listed | Not listed | Yes |
| No API key required | Yes | Not listed | Not listed | Not listed |

### Configure the run

Drive the Actor with a single search query for an artist, song, or keyword, and set a maximum number of songs to cap the run. The Input tab lists every parameter.

A first run with the defaults:

```json
{
 "searchQuery": "Drake",
 "maxItems": 10
}
```

A larger pull:

```json
{
 "searchQuery": "Drake",
 "maxItems": 200
}
```

### Pricing

Pay-per-result: **$0.021 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $2.10 |
| 1,000 results | $21.00 |
| 10,000 results | $210.00 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [Genius Lyrics Scraper](https://apify.com/parseforge/genius-lyrics-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to Genius through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

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

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results for my search query?**

Check that your search query is spelled correctly and is not too specific. Try a broader query, such as the artist name, and increase the maxItems value to ensure you capture all available results.

**Why is the run so slow when I enable lyrics?**

Fetching full lyrics requires visiting each individual song page, which adds one request per song. For faster runs, disable the 'Include Lyrics' option and collect metadata only.

**Why are some lyrics missing or incomplete?**

Genius may not have full lyrics for every song, or the lyrics may be behind a paywall or restricted. The Actor returns whatever text is publicly available on the page.

**Why did my run stop before reaching the maxItems I set?**

Genius search results are paginated and may return fewer total songs than your maxItems value. The Actor collects all available results up to your limit, but cannot create results that do not exist.

**Why do I see duplicate songs in my dataset?**

Genius sometimes lists the same song under multiple URLs or with slight title variations. Deduplicate your dataset after the run using the song title and primary artist fields as a composite key.

### FAQ

| Question | Answer |
|---|---|
| Does this Actor require a Genius API key? | No. It reads the public search results and song pages directly, so you do not need to register an application or obtain an API key. |
| How do I get the full lyrics for each song? | Set the 'Include Lyrics' input option to true. The Actor will then visit each song's page and extract the complete lyrics text. This takes longer and uses more requests than metadata-only runs. |
| What metadata fields does the Actor return? | Each result includes the song title, primary artist, album name, release date, Genius page URL, and the song's header image URL. When lyrics are enabled, the full lyrics text is added. |
| Can I scrape lyrics for a specific song? | Yes. Enter the song title and artist name together in the search query, for example 'Eminem Lose Yourself', and the Actor will find the best match. |
| How many songs can I scrape in one run? | You set the maximum with the 'Maximum songs' input. The upper limit is one million songs per run, though the actual number returned depends on how many results Genius returns for your query. |
| Does this Actor handle non-English lyrics? | Yes. Genius hosts lyrics in many languages. Search for artists or songs in any language and the Actor will return whatever Genius has available. |
| What output formats are supported? | You can export your dataset in CSV, JSON, Excel, or XML formats from the Apify platform after the run completes. |
| Can I search by album name? | The search query accepts any text string, including album names. Enter the album title and the Actor will return songs that match. |
| Is there a way to get only songs with lyrics? | The Actor returns all songs matching your search query. You can filter the output dataset after the run to keep only rows where the lyrics field is populated. |
| Does this Actor scrape annotations or song meanings? | No. This Actor focuses on song metadata and lyrics. Annotations, meanings, and user-contributed explanations are not included in the output. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by ML Genius Holdings, LLC. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

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

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

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

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

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

How many songs to collect per run.

## Actor input object example

```json
{
  "searchQuery": "Drake",
  "includeLyrics": false,
  "maxItems": 10
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "searchQuery": "Drake",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/genius-lyrics-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchQuery": "Drake",
    "maxItems": 10,
}

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

# Fetch and print Actor results from the run's dataset (if there are any)
print(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 '{
  "searchQuery": "Drake",
  "maxItems": 10
}' |
apify call parseforge/genius-lyrics-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/genius-lyrics-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/d8jCIU0MqAupQrFzw/builds/OXdNgdW0P6MSRGOKU/openapi.json