# Udio Music Search Scraper (`automation-lab/udio-music-search-scraper`) Actor

🎵 Search public Udio songs and export ranked creators, prompts, tags, media URLs, engagement, and timestamps for music intelligence and monitoring.

- **URL**: https://apify.com/automation-lab/udio-music-search-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** AI
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 1,000 song 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

## Udio Music Search Scraper

Search Udio's public music catalog and export ranked songs as clean JSON, CSV, Excel, XML, or RSS data.

Use genres, moods, artist names, titles, or prompt phrases. Every record includes its original query and rank, making repeated snapshots useful for discovery, creator intelligence, and trend monitoring.

### What does Udio Music Search Scraper do?

The Actor sends read-only searches to Udio's public catalog and saves structured song records.

It can collect:

- Song IDs and public URLs
- Search query and rank
- Song titles
- Creator names and IDs
- Public prompts and descriptions
- Genre and style tags
- Duration
- Artwork, audio, and video URLs
- Public play and like counts
- Creation and publication times
- A consistent scrape timestamp

It does not create music, sign in to accounts, or access private libraries.

### Who is it for?

#### AI music analysts

Build datasets that compare styles, prompts, creators, and visible engagement.

#### Labels and A\&R teams

Discover public tracks and creators across genres, moods, and emerging niches.

#### Creator intelligence teams

Find creators attached to relevant songs and measure their public catalog signals.

#### Researchers

Collect reproducible snapshots for studies of generative music and cultural trends.

#### Developers

Add public Udio discovery data to dashboards, alerts, enrichment pipelines, or internal tools.

### Why use this Udio scraper?

- No browser automation is required.
- Multiple queries run in one Actor execution.
- Cursor pagination supports larger result sets.
- Per-query limits keep costs predictable.
- Duplicate song IDs are removed within each query.
- Optional public fields stay nullable instead of being fabricated.
- Results work with Apify schedules, webhooks, API clients, and integrations.

### What Udio data can I extract?

| Field | Type | Meaning |
|---|---|---|
| `query` | string | Search phrase submitted |
| `rank` | number | Position within that query |
| `songId` | string | Stable Udio song ID |
| `songUrl` | string | Public Udio song page |
| `title` | string | Public song title |
| `creatorName` | string | Public creator name |
| `creatorId` | string or null | Public creator identifier |
| `prompt` | string or null | Public music prompt |
| `description` | string or null | Public description |
| `tags` | string\[] | Genres and style tags |
| `durationSeconds` | number or null | Audio duration |
| `artworkUrl` | string or null | Cover image URL |
| `audioUrl` | string or null | Public audio URL |
| `videoUrl` | string or null | Public video URL |
| `plays` | number or null | Visible play count |
| `likes` | number or null | Visible like count |
| `createdAt` | string or null | Creation timestamp |
| `publishedAt` | string or null | Publication timestamp |
| `scrapedAt` | string | Collection timestamp |

### How to scrape Udio songs

1. Open the Actor in Apify Console.
2. Add one or more search queries.
3. Choose the maximum songs per query.
4. Click **Start**.
5. Preview records in the Dataset tab.
6. Export the dataset or connect an integration.

A cheap first run uses one query and 20 songs.

### Input

```json
{
  "queries": ["ambient", "synthwave"],
  "maxItemsPerQuery": 50
}
```

#### `queries`

Required array of non-empty strings.

Useful query types include:

- Genres: `ambient`, `synthwave`, `jazz`
- Moods: `melancholic`, `uplifting`, `dreamy`
- Instruments: `solo piano`, `electric guitar`
- Use cases: `cinematic trailer`, `focus music`
- Prompt phrases: `female vocal electronic pop`
- Creator or title fragments

#### `maxItemsPerQuery`

Maximum records saved for each query.

The allowed range is 1 to 1,000.

Use a low value while testing and increase it for monitoring or analysis.

### Output example

```json
{
  "query": "synthwave",
  "rank": 1,
  "songId": "example-song-id",
  "songUrl": "https://www.udio.com/songs/example-song-id",
  "title": "Neon Pulse",
  "creatorName": "Example creator",
  "creatorId": "example-creator-id",
  "prompt": "retro synthwave, nocturnal, energetic",
  "description": "",
  "tags": ["synthwave", "electronic"],
  "durationSeconds": 132.4,
  "artworkUrl": "https://example.com/artwork",
  "audioUrl": "https://example.com/audio.mp3",
  "videoUrl": null,
  "plays": 1200,
  "likes": 84,
  "createdAt": "2026-01-01T00:00:00Z",
  "publishedAt": "2026-01-01T00:05:00Z",
  "scrapedAt": "2026-07-12T00:00:00Z"
}
```

Actual values come from public Udio responses.

### How much does it cost to scrape Udio songs?

This Actor uses pay-per-event pricing:

- A small one-time Start event covers run setup.
- An Item event is charged for every dataset record.
- Higher Apify plan tiers receive lower per-item prices.

Your exact total appears in Console before and after a run. Keep the per-query limit low for experiments, then scale once the output fits your workflow.

### Udio search monitoring workflow

A practical recurring workflow is:

1. Save a stable set of queries.
2. Schedule the Actor daily or weekly.
3. Store each dataset snapshot.
4. Join records by `songId` and `query`.
5. Compare ranks, plays, likes, and publication times.
6. Send alerts for new or rising songs.

The `scrapedAt` field makes snapshots easy to order.

### Tips for reliable results

- Use specific phrases when broad genres are noisy.
- Keep related concepts in separate queries to preserve ranks.
- Use song IDs, not titles, for deduplication across runs.
- Treat media links as public upstream URLs that may change.
- Expect optional fields to be null when Udio does not expose them.
- Schedule at consistent times for comparable snapshots.
- Export raw datasets before applying aggressive filtering.

### Apify integrations

Send results to:

- Google Sheets for editorial review
- Slack for new-song alerts
- Make for no-code enrichment workflows
- Zapier for CRM or notification automations
- Webhooks for event-driven processing
- Cloud storage for long-term snapshots
- SQL warehouses for rank and engagement analysis

For example, trigger a webhook after each scheduled run, compare song IDs with yesterday's snapshot, and notify an A\&R channel about newly ranked tracks.

### API usage: run with the Apify API

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/udio-music-search-scraper').call({
  queries: ['ambient', 'synthwave'],
  maxItemsPerQuery: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/udio-music-search-scraper').call(run_input={
    'queries': ['cinematic orchestral'],
    'maxItemsPerQuery': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~udio-music-search-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["ambient"],"maxItemsPerQuery":50}'
```

Use the returned dataset ID to download results.

### Use with MCP and AI agents

Connect through the Apify MCP server at:

`https://mcp.apify.com?tools=automation-lab/udio-music-search-scraper`

#### Claude Code

Add the actor as a remote HTTP MCP server with this runnable command:

```bash
claude mcp add --transport http apify-udio "https://mcp.apify.com?tools=automation-lab/udio-music-search-scraper"
```

Then ask:

- “Find 100 newly relevant ambient songs on Udio.”
- “Compare Udio synthwave search results for these four queries.”
- “Export creator names and prompts for cinematic trailer tracks.”

#### Claude Desktop, Cursor, and VS Code

Add the following entry to your client's MCP JSON configuration (`claude_desktop_config.json` in Claude Desktop, `.cursor/mcp.json` in Cursor, or `.vscode/mcp.json` in VS Code):

```json
{
  "mcpServers": {
    "apify-udio": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/udio-music-search-scraper"
    }
  }
}
```

Restart or reload the client after saving. The assistant can then start actor runs and inspect structured datasets without copying data manually.

### Scheduling and alerts

Apify schedules can run the same input hourly, daily, weekly, or on a custom cron pattern.

Recommended setup:

- Daily for fast-moving genre intelligence
- Weekly for catalog research
- Monthly for broad academic snapshots

Attach a webhook to notify your service when the run succeeds or fails.

### Data quality and limitations

Search relevance and public field availability are controlled by Udio.

The Actor cannot guarantee:

- A fixed ranking between runs
- Complete historical engagement
- Availability of every artwork or media URL forever
- Private or unpublished songs
- Account-specific personalization
- Music creation or download rights

The Actor exports what the public read-only search service exposes at run time.

### Legality: is it legal to scrape Udio?

This Actor is designed for publicly available data. Laws, contractual terms, copyright rules, and permitted uses vary by country and project.

You are responsible for:

- Having a lawful purpose
- Respecting Udio's terms and applicable law
- Avoiding personal-data misuse
- Respecting copyright and media licenses
- Applying appropriate retention and security controls

Do not use the Actor to access private data or bypass authentication.

### FAQ

#### Does it require a Udio account?

No. The supported scope is public, read-only song search.

#### Can it create songs?

No. Music generation and account actions are intentionally out of scope.

#### Can I search several phrases at once?

Yes. Add each phrase to `queries`; each result keeps its own query and rank.

#### Why are some fields null?

Udio does not expose every optional field for every public song. Null values accurately represent missing upstream data.

#### Why do rankings change?

Udio controls search relevance, catalog availability, and engagement signals. Use scheduled snapshots to measure change rather than assuming static positions.

#### A run returned fewer songs than requested. What happened?

The public search may have reached the end of available results, returned duplicates, or exposed fewer matches. Try a broader query or lower limit.

#### How do I avoid duplicate songs?

Within one query, the Actor removes duplicate song IDs. Across multiple queries or runs, deduplicate by `songId` while retaining query and timestamp columns when rank context matters.

### Related scrapers

Explore other data tools from [automation-lab](https://apify.com/automation-lab) for creator intelligence, social monitoring, music research, and public web datasets.

Combine this Actor with related social or creator scrapers when you need broader audience signals beyond Udio's public catalog.

### Support

If a public Udio response changes or an expected field disappears, open an issue from the Actor page with:

- The exact input
- The run ID
- The affected query
- A short description of expected and actual output

This evidence helps reproduce and resolve problems quickly.

# Actor input Schema

## `queries` (type: `array`):

Keywords, genres, moods, creators, or prompt phrases to search on Udio.

## `maxItemsPerQuery` (type: `integer`):

Maximum ranked public songs saved for each query.

## Actor input object example

```json
{
  "queries": [
    "ambient",
    "synthwave"
  ],
  "maxItemsPerQuery": 20
}
```

# Actor output Schema

## `overview` (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 = {
    "queries": [
        "ambient",
        "synthwave"
    ],
    "maxItemsPerQuery": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/udio-music-search-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 = {
    "queries": [
        "ambient",
        "synthwave",
    ],
    "maxItemsPerQuery": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/udio-music-search-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 '{
  "queries": [
    "ambient",
    "synthwave"
  ],
  "maxItemsPerQuery": 20
}' |
apify call automation-lab/udio-music-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/udio-music-search-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/meWp5FRdWfwluLzda/builds/DhElZPMTdnUknQLhi/openapi.json