# Musescore Scraper (`maximedupre/musescore-scraper`) Actor

Scrape public Musescore sheet music results from search terms or Musescore URLs. Export score links, titles, publishers, thumbnails, metrics, tags, and instruments.

- **URL**: https://apify.com/maximedupre/musescore-scraper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.45 / 1,000 scraped scores

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

### 🎼 Musescore scraper for sheet music results

Musescore Scraper collects public sheet music results from [Musescore](https://musescore.com/). Add plain search terms such as `golden hour piano`, paste Musescore search or listing URLs, or mix both in one run. The Actor saves clean rows with score URLs, titles, publishers, thumbnails, visible score details, engagement metrics, tags, instruments, and scrape timestamps.

Use this Musescore scraper when you need repeatable sheet music discovery data for catalog research, music education research, content planning, repertoire lists, trend tracking, or internal data workflows. You do not need a Musescore account, cookies, login details, or an API key.

For a quick first run, keep the prefilled `golden hour piano` search term and the default limit of 25 results. The Actor searches public Musescore result pages, saves accepted score cards during the run, and stops at your `maxItems` limit.

### ✅ What this Actor does

- Searches Musescore from one or more plain search terms.
- Accepts public Musescore search, sheet music, tag, and instrument listing URLs.
- Saves one dataset item for each accepted public sheet music result.
- Exports score links, score IDs, titles, publishers, publisher profile URLs, and cover thumbnails.
- Adds visible score details such as parts, pages, duration, upload date, views, saves, votes, tags, difficulty, and instruments when Musescore shows them.
- Keeps source provenance with the original search query or URL, resolved search URL, target index, source position, and scrape time.
- Deduplicates the same score URL across all submitted targets in one run.
- Stops at your total result limit.

Unavailable fields are saved as `null` or empty arrays instead of guessed values. Invalid or empty inputs are reported in logs instead of fake dataset rows.

### 📦 Data you can export

Each output row represents one public Musescore sheet music result. Fields can include:

- `searchQuery`, `startUrl`, `resolvedSearchUrl`, `targetIndex`, and `sourcePosition`
- `scoreId`, `scoreUrl`, and `title`
- `publisher` and `publisherUrl`
- `coverImageUrl` and `coverImageAlt`
- `parts`, `pages`, `duration`, `uploadDateText`, and `uploadDate`
- `viewsText`, `views`, `favoritesText`, `favorites`, `voteCountText`, and `voteCount`
- `tags`, `difficulty`, and `instruments`
- `detailsRaw`, `scrapedAt`, and `status`

You can open the dataset in Apify, export it as JSON, CSV, Excel, XML, RSS, or HTML, call it through the Apify API, schedule repeat runs, or connect it to webhooks and integrations.

### ▶️ How to run it

1. Add one or more Musescore search terms, Musescore URLs, or both.
2. Keep `Maximum results` at `25` for a small first run.
3. Run the Actor.
4. Open the dataset and check the score URLs, metadata, and source positions.
5. Raise the limit or add more targets once the output shape matches what you need.

Example input:

```json
{
	"searchQueries": ["golden hour piano", "moonlight sonata piano"],
	"startUrls": [
		{
			"url": "https://musescore.com/sheetmusic?text=golden%20hour"
		}
	],
	"maxItems": 25
}
````

### 🔎 Input options

`searchQueries` are plain Musescore searches. Use song titles, artists, instruments, arrangement types, or any phrase you would type into Musescore search.

`startUrls` are public Musescore search or listing URLs. Use them when you already have a Musescore page with source-native filters, tags, instruments, or order that you want to preserve.

`maxItems` is the total number of sheet music rows to save across all search terms and URLs. The default is `25`, and the maximum is `10000`.

### 🧾 Output example

```json
{
	"searchQuery": "golden hour piano",
	"startUrl": null,
	"resolvedSearchUrl": "https://musescore.com/sheetmusic?text=golden+hour+piano",
	"targetIndex": 0,
	"sourcePosition": 1,
	"scoreId": "6929025",
	"scoreUrl": "https://musescore.com/user/39593079/scores/6929025",
	"title": "Golden hour - Kacey Musgraves (Easy Piano)",
	"publisher": "Hal Leonard",
	"publisherUrl": "https://musescore.com/official_scores",
	"coverImageUrl": "https://cdn.ustatik.com/musescore/scoredata/g/00924cd304f1a8c4abd029203747f625d910d698/score_0.png@500x660?no-cache=1718098745&bgclr=ffffff",
	"coverImageAlt": "[b]Golden[/b] [b]hour[/b] - Kacey Musgraves (Easy [b]Piano[/b]) sheet music arranged by Hal Leonard for Solo",
	"parts": 1,
	"pages": 5,
	"duration": "03:09",
	"uploadDateText": "Aug 20, 2021",
	"uploadDate": "2021-08-20",
	"viewsText": "103.8K",
	"views": 103800,
	"favoritesText": "325",
	"favorites": 325,
	"voteCountText": "77",
	"voteCount": 77,
	"tags": ["Official", "Beginner"],
	"difficulty": "Beginner",
	"instruments": ["Solo Piano", "Piano"],
	"detailsRaw": "1 part • 5 pages • 03:09 • Aug 20, 2021 • 103.8K views • 325 saves",
	"scrapedAt": "2026-06-14T14:33:36.709Z",
	"status": "ok"
}
```

Real rows may include different fields as `null` when Musescore does not show that value on the result card.

### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged for each saved sheet music result. There is no separate Actor-start charge.

The price is `$4.45` per 1,000 saved results, or `$0.00445` per result.

### ⚠️ Limits and caveats

- The Actor collects public Musescore search and listing data only.
- It does not download PDFs, audio files, MIDI files, score files, or copyrighted sheet music assets.
- It does not scrape private scores, logged-in-only pages, account-specific data, or paywalled content.
- Search order, available fields, and result visibility depend on what Musescore shows publicly at run time.
- Some result cards may omit publisher, date, metrics, tags, difficulty, or instrument data.
- The Actor is not affiliated with Musescore and is not an official Musescore API client.

### ❓ FAQ

#### 🔑 Do I need a Musescore account?

No. The Actor is designed for public Musescore result pages and does not ask for Musescore cookies, login details, or an API key.

#### 🔗 Can I use Musescore URLs instead of search terms?

Yes. Paste public Musescore search, sheet music, tag, or instrument listing URLs in `Musescore search URLs`. The Actor preserves the source page's filters and order when Musescore exposes score cards.

#### 📄 Does it download sheet music files?

No. This is a metadata and search-result scraper. It saves public score links, thumbnails, visible details, and metrics, but it does not download PDFs, audio, MIDI, or score files.

#### 📊 Can I use the output as a Musescore API?

Yes, through Apify. You can run the Actor via the Apify API, schedule repeat runs, export datasets, or connect runs to webhooks and integrations.

#### 🧩 Why are some fields null?

Musescore does not show every field on every result card. The Actor keeps missing scalar values as `null` and missing lists as empty arrays instead of guessing.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~musescore-scraper/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [SoundCloud Scraper ↗](https://apify.com/maximedupre/soundcloud-scraper) - Export public music tracks, artists, playlists, albums, and comments.
- [YouTube Channel Search Scraper ↗](https://apify.com/maximedupre/youtube-channel-search-scraper) - Find public YouTube channels from search keywords.
- [YouTube Channel Scraper ↗](https://apify.com/maximedupre/youtube-channel-scraper) - Scrape profiles and video rows from known YouTube channels.
- [Unsplash Image Scraper ↗](https://apify.com/maximedupre/unsplash-image-scraper) - Collect image search results from Unsplash keywords.
- [Web Images Scraper ↗](https://apify.com/maximedupre/web-images-scraper) - Extract image URLs and metadata from public webpages.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

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

Enter song, artist, instrument, or arrangement searches. Use this when you do not already have a Musescore URL.

## `startUrls` (type: `array`):

Paste Musescore search, sheet music, tag, or instrument listing URLs when you want to keep the source page's filters and order.

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

Maximum sheet-music rows to save across all search terms and URLs.

## Actor input object example

```json
{
  "searchQueries": [
    "golden hour piano"
  ],
  "startUrls": [
    {
      "url": "https://musescore.com/sheetmusic?text=golden%20hour"
    }
  ],
  "maxItems": 25
}
```

# Actor output Schema

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

Open the dataset with one item per public Musescore sheet music result.

# 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": [
        "golden hour piano"
    ],
    "startUrls": [
        {
            "url": "https://musescore.com/sheetmusic?text=golden%20hour"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/musescore-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": ["golden hour piano"],
    "startUrls": [{ "url": "https://musescore.com/sheetmusic?text=golden%20hour" }],
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/musescore-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": [
    "golden hour piano"
  ],
  "startUrls": [
    {
      "url": "https://musescore.com/sheetmusic?text=golden%20hour"
    }
  ]
}' |
apify call maximedupre/musescore-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Musescore Scraper",
        "description": "Scrape public Musescore sheet music results from search terms or Musescore URLs. Export score links, titles, publishers, thumbnails, metrics, tags, and instruments.",
        "version": "0.1",
        "x-build-id": "Dn9AJV7C8iC4P2f9p"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~musescore-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-musescore-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/maximedupre~musescore-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-musescore-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/maximedupre~musescore-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-musescore-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 terms",
                        "maxItems": 1000,
                        "type": "array",
                        "description": "Enter song, artist, instrument, or arrangement searches. Use this when you do not already have a Musescore URL.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "startUrls": {
                        "title": "Musescore search URLs",
                        "maxItems": 1000,
                        "type": "array",
                        "description": "Paste Musescore search, sheet music, tag, or instrument listing URLs when you want to keep the source page's filters and order.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "title": "URL",
                                    "type": "string",
                                    "description": "Musescore search or listing URL.",
                                    "minLength": 1
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum sheet-music rows to save across all search terms and URLs.",
                        "default": 25
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```