Merge

Solution · Music

Agentic AI Master Data Management for the Music Industry with Merge: From Fragmented Catalogs to Unified Artist Intelligence

How identity-based resolution, agentic AI matching, and graph traversal turn scattered music metadata into a unified master data platform.

Dashboard showing 24 entities created and 5 merges performed

The Multi-Platform Music Data Problem

Every music-tech company faces the same fragmentation challenge. The Weeknd appears on Spotify as "The Weeknd" with genre "R&B/Pop." Apple Music lists him as "The Weeknd" under "R&B." Tidal catalogs "Jay-Z" while Spotify has "Jay-Z" and a fan wiki writes "Jay Z" without the hyphen. Ticketmaster sells tickets for "Coachella" while Wikipedia references "Coachella Valley Music and Arts Festival."

Same artist, same venue, same label — but your database sees six different entries where there should be one.

Multiply this across thousands of artists, hundreds of thousands of albums, venue partnerships, label rosters, and touring schedules, and you're looking at a metadata nightmare. Traditional deduplication — exact string matching, manual curation, or rigid ETL rules — cannot keep up with the volume, velocity, and inconsistency of music industry data.

This is the problem Merge solves. In this post, we'll walk through building a complete music industry master data graph that:

  • Ingests artist, album, label, and venue records from multiple platforms simultaneously
  • Automatically merges records that share a verified identity key (like a Spotify artist ID)
  • Uses agentic AI to evaluate uncertain matches and route ambiguous cases for human review
  • Creates a traversable relationship graph connecting artists to labels, albums, venues, and collaborators
  • Handles search with typo tolerance so "Kendrik Lamarr" still finds Kendrick Lamar

By the end, you'll see how 24 raw source records become clean golden entities connected by 23 relationship edges — with rich multi-hop graph traversal revealing hidden connections like shared labels and venues.

Schema Design: Identity Keys for Deterministic Resolution

Before ingesting any data, we define our entity schemas. The critical design decision: which fields get marked with identity: true. An identity field tells Merge that when two records share the same value in that field, they are definitively the same entity and should be merged automatically — no AI evaluation needed.

Entity Schemas

We define four entity types. Artist and Album include identity fields because music platforms assign stable external identifiers (Spotify IDs, ISRC codes, etc.):

# Artist schema — external_id is the identity key
curl -X POST https://merge-ai.app/v1/schemas \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Artist",
    "attributes": [
      { "name": "name", "type": "string", "required": true },
      { "name": "genre", "type": "string" },
      { "name": "origin", "type": "string" },
      { "name": "active_since", "type": "string" },
      { "name": "external_id", "type": "string", "identity": true }
    ]
  }'

# Album schema — also with identity key
curl -X POST https://merge-ai.app/v1/schemas \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Album",
    "attributes": [
      { "name": "title", "type": "string", "required": true },
      { "name": "release_year", "type": "string" },
      { "name": "genre", "type": "string" },
      { "name": "external_id", "type": "string", "identity": true }
    ]
  }'

# Label schema — no identity key (resolved by name similarity)
curl -X POST https://merge-ai.app/v1/schemas \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Label",
    "attributes": [
      { "name": "name", "type": "string", "required": true },
      { "name": "parent_company", "type": "string" },
      { "name": "headquarters", "type": "string" }
    ]
  }'

# Venue schema — no identity key
curl -X POST https://merge-ai.app/v1/schemas \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Venue",
    "attributes": [
      { "name": "name", "type": "string", "required": true },
      { "name": "city", "type": "string" },
      { "name": "capacity", "type": "string" },
      { "name": "venue_type", "type": "string" }
    ]
  }'

Schema configuration showing Artist and Album with identity:true fields

Why Identity Matters for Music Data

The identity: true flag on external_id tells Merge: "If two records share the same value in this field, they are definitively the same entity — merge them instantly, no questions asked."

This maps perfectly to how the music industry works. When Spotify assigns artist ID SPOT-1Xyo to The Weeknd, and Apple Music references that same ID in their catalog feed, Merge knows instantly they represent the same artist. No AI inference needed, no review queue delay — just immediate, deterministic unification.

For Labels and Venues, we intentionally omit identity keys. These entities don't have universal cross-platform identifiers, so Merge relies on its agentic AI layer to evaluate similarity when potential duplicates arrive.

Schema Identity Field Resolution Behavior
Artist external_id Same ID → instant auto-merge
Album external_id Same ID → instant auto-merge
Label (none) AI evaluates name + attributes
Venue (none) AI evaluates name + location

Relationships: The Connectivity Model

Entities in isolation are metadata. Entities connected by relationships become a master data graph. We define four relationship types that capture the core structure of the music industry:

# Artist signed to Label
curl -X POST https://merge-ai.app/v1/relationships \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "name": "signed_to", "from_type": "Artist", "to_type": "Label" }'

# Album released on Label
curl -X POST https://merge-ai.app/v1/relationships \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "name": "released_on", "from_type": "Album", "to_type": "Label" }'

# Album created by Artist
curl -X POST https://merge-ai.app/v1/relationships \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "name": "created_by", "from_type": "Album", "to_type": "Artist" }'

# Artist performed at Venue
curl -X POST https://merge-ai.app/v1/relationships \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "name": "performed_at", "from_type": "Artist", "to_type": "Venue" }'

Multi-Hop Discovery Paths

These four relationship types enable powerful multi-hop graph traversal. Starting from any album, you can trace outward to discover connections that would be invisible in a flat database:

Album → created_by → Artist → performed_at → Venue ← performed_at ← (other artists)
  │                    │
  └── released_on ──→ Label ←── signed_to ←── (other artists on same label)

For example, starting from the album "After Hours":

  • Hop 1: After Hours → created_by → The Weeknd
  • Hop 2: The Weeknd → signed_to → XO Records; The Weeknd → performed_at → Coachella
  • Hop 3: XO Records ← signed_to ← Drake; Coachella ← performed_at ← Kendrick Lamar

One query reveals that Drake and The Weeknd are labelmates, and that Kendrick Lamar performed at the same festival. These connections emerge naturally from the graph structure without any manual curation.

Loading Connected Data

With schemas and relationships defined, we ingest records from multiple sources. Each entity arrives with its relationships, building the graph as data flows in.

Labels

# Ingest record labels
curl -X POST https://merge-ai.app/v1/entities \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Label",
    "attributes": {
      "name": "XO Records",
      "parent_company": "Republic Records",
      "headquarters": "Toronto"
    },
    "source": "music_db"
  }'

# Additional labels: Interscope, Parlophone, Roc Nation

We load four labels: XO Records (Republic/Universal), Interscope Records (Universal Music Group), Parlophone Records (Warner Music Group), and Roc Nation (Live Nation).

Venues

# Ingest performance venues
curl -X POST https://merge-ai.app/v1/entities \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Venue",
    "attributes": {
      "name": "Madison Square Garden",
      "city": "New York",
      "capacity": "20789",
      "venue_type": "Arena"
    },
    "source": "music_db"
  }'

# Additional venues: Coachella, Glastonbury, Wembley Stadium

Four iconic venues: Madison Square Garden (Arena, NYC), Coachella Valley Music and Arts Festival (Festival, Indio), Glastonbury Festival (Festival, Somerset), and Wembley Stadium (Stadium, London).

Artists with External IDs

Here's where the identity resolution story begins. Each artist carries an external_id matching their Spotify artist identifier, plus relationships to their label and primary performance venue:

# The Weeknd — from Spotify catalog
curl -X POST https://merge-ai.app/v1/entities \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Artist",
    "attributes": {
      "name": "The Weeknd",
      "genre": "R&B/Pop",
      "origin": "Toronto",
      "active_since": "2009",
      "external_id": "SPOT-1Xyo"
    },
    "source": "spotify",
    "relationships": [
      { "relationship_type": "signed_to", "to_entity_id": "ent_xo_records_id" },
      { "relationship_type": "performed_at", "to_entity_id": "ent_coachella_id" }
    ]
  }'

We ingest six artists from the Spotify catalog feed:

Artist Genre External ID Label Venue
The Weeknd R&B/Pop SPOT-1Xyo XO Records Coachella
Kendrick Lamar Hip-Hop SPOT-2YZy Interscope Records Coachella
Jay-Z Hip-Hop SPOT-3nFk Roc Nation Madison Square Garden
Billie Eilish Pop/Electropop SPOT-6qqN Interscope Records Glastonbury Festival
Coldplay Alternative Rock SPOT-4gzp Parlophone Records Wembley Stadium
Drake Hip-Hop/R&B SPOT-3TVX XO Records Madison Square Garden

Albums with Relationships

Each album links to its artist (created_by) and its label (released_on):

# After Hours — linked to The Weeknd and XO Records
curl -X POST https://merge-ai.app/v1/entities \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Album",
    "attributes": {
      "title": "After Hours",
      "release_year": "2020",
      "genre": "Synth-pop/R&B",
      "external_id": "ALB-AH2020"
    },
    "source": "spotify",
    "relationships": [
      { "relationship_type": "created_by", "to_entity_id": "ent_weeknd_id" },
      { "relationship_type": "released_on", "to_entity_id": "ent_xo_records_id" }
    ]
  }'

Eight albums across the roster:

Album Year Artist Label
After Hours 2020 The Weeknd XO Records
Dawn FM 2022 The Weeknd XO Records
DAMN. 2017 Kendrick Lamar Interscope Records
4:44 2017 Jay-Z Roc Nation
Happier Than Ever 2021 Billie Eilish Interscope Records
A Head Full of Dreams 2015 Coldplay Parlophone Records
Take Care 2011 Drake XO Records
The Blueprint 2001 Jay-Z Roc Nation

Entity list showing all ingested artists, albums, labels, and venues

Identity Auto-Merge: When the Same Artist Arrives from a Different Platform

Now we demonstrate the core identity resolution capability. The Weeknd already exists from the Spotify feed with external_id: "SPOT-1Xyo". What happens when Apple Music sends us their version of the same artist?

The Weeknd from Apple Music

# Same artist, different source, same external_id
curl -X POST https://merge-ai.app/v1/entities \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Artist",
    "attributes": {
      "name": "The Weeknd",
      "genre": "R&B",
      "origin": "Toronto, Canada",
      "active_since": "2009",
      "external_id": "SPOT-1Xyo"
    },
    "source": "apple-music"
  }'

Because both records carry external_id: "SPOT-1Xyo" and the Artist schema marks external_id with identity: true, Merge instantly recognizes these as the same entity. No AI evaluation, no review queue — instant deterministic merge.

Jay Z from Tidal

# Jay-Z on Tidal — note the name variation: "Jay Z" (no hyphen)
curl -X POST https://merge-ai.app/v1/entities \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Artist",
    "attributes": {
      "name": "Jay Z",
      "genre": "Hip-Hop/Rap",
      "origin": "Brooklyn, New York",
      "active_since": "1986",
      "external_id": "SPOT-3nFk"
    },
    "source": "tidal"
  }'

Same pattern: Tidal's record has external_id: "SPOT-3nFk" matching the existing Spotify entry. Despite Tidal writing "Jay Z" (no hyphen) and listing origin as "Brooklyn, New York" instead of "New York," the identity key match triggers instant auto-merge.

Verifying the Merged Entity

After both merges complete, The Weeknd now has two source records unified under one golden entity:

curl https://merge-ai.app/v1/entities/ent_246d0a3e-9796-459a-b8c2-83787a4582fa/sources \
  -H "X-API-Key: YOUR_API_KEY"

{
  "sources": [
    {
      "source_system": "apple-music",
      "raw": "{\"active_since\":\"2009\",\"external_id\":\"SPOT-1Xyo\",\"genre\":\"R&B\",\"name\":\"The Weeknd\",\"origin\":\"Toronto, Canada\"}"
    },
    {
      "source_system": "spotify",
      "raw": "{\"active_since\":\"2009\",\"external_id\":\"SPOT-1Xyo\",\"genre\":\"R&B/Pop\",\"name\":\"The Weeknd\",\"origin\":\"Toronto\"}"
    }
  ]
}

And Jay-Z shows both Spotify and Tidal contributing to the same golden record:

{
  "sources": [
    {
      "source_system": "tidal",
      "raw": "{\"active_since\":\"1986\",\"external_id\":\"SPOT-3nFk\",\"genre\":\"Hip-Hop/Rap\",\"name\":\"Jay Z\",\"origin\":\"Brooklyn, New York\"}"
    },
    {
      "source_system": "spotify",
      "raw": "{\"active_since\":\"1986\",\"external_id\":\"SPOT-3nFk\",\"genre\":\"Hip-Hop\",\"name\":\"Jay-Z\",\"origin\":\"New York\"}"
    }
  ]
}

The Weeknd entity showing 2 merged sources from Spotify and Apple Music

What Identity Resolution Achieves

The golden entity preserves complete lineage while presenting a unified view:

Attribute Spotify Apple Music Golden Entity
name The Weeknd The Weeknd The Weeknd
genre R&B/Pop R&B R&B/Pop
origin Toronto Toronto, Canada Toronto
external_id SPOT-1Xyo SPOT-1Xyo SPOT-1Xyo

Both source records remain queryable for audit and data quality tracking, but downstream consumers see one clean entity with one set of relationships.

Agentic AI Matching: When There's No Shared Identifier

Identity keys handle the deterministic cases. But what about records that arrive without external IDs, or entities (like Labels and Venues) that don't have universal identifiers at all? This is where Merge's agentic AI matching layer takes over.

We test three scenarios that exercise different confidence thresholds:

Scenario 1: "Gorillaz" vs "Gorillas" — Typo Creates Ambiguity

# First: the canonical "Gorillaz" from our music database
curl -X POST https://merge-ai.app/v1/entities \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Artist",
    "attributes": {
      "name": "Gorillaz",
      "genre": "Alternative/Electronic",
      "origin": "London",
      "active_since": "1998"
    },
    "source": "music_db"
  }'

# Then: a fan wiki with a typo — "Gorillas" instead of "Gorillaz"
curl -X POST https://merge-ai.app/v1/entities \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Artist",
    "attributes": {
      "name": "Gorillas",
      "genre": "Alternative/Electronic",
      "origin": "London",
      "active_since": "1998"
    },
    "source": "fan-wiki"
  }'

The AI evaluates multiple signals:

  • Name similarity: "Gorillaz" vs "Gorillas" — very close (one character difference)
  • Genre match: Both "Alternative/Electronic" — exact
  • Origin match: Both "London" — exact
  • Active since: Both "1998" — exact

With all supporting attributes aligned but the name being only one character apart, this could be a typo OR a genuinely different band. The AI assigns a confidence score of 0.72 — above the threshold for creating a review, but below the auto-merge threshold.

The system created a review for human judgment, and after acceptance, merged them into a single entity with both sources preserved:

{
  "entity_id": "ent_9bd39123-4899-434e-b948-ca6efbb06cb9",
  "name": "Gorillas",
  "confidence_score": "0.72",
  "source_count": 2,
  "sources": [
    { "source_system": "music_db", "name": "Gorillaz" },
    { "source_system": "fan-wiki", "name": "Gorillas" }
  ]
}

Scenario 2: "Sony Music" vs "Sony Music Entertainment" — AI Auto-Merge

# Short form from music database
curl -X POST https://merge-ai.app/v1/entities \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Label",
    "attributes": {
      "name": "Sony Music",
      "parent_company": "Sony Group",
      "headquarters": "New York"
    },
    "source": "music_db"
  }'

# Full legal name from Wikipedia
curl -X POST https://merge-ai.app/v1/entities \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Label",
    "attributes": {
      "name": "Sony Music Entertainment",
      "parent_company": "Sony Group",
      "headquarters": "New York City"
    },
    "source": "wikipedia"
  }'

Here the AI confidence is high enough for auto-merge:

  • "Sony Music" is a substring of "Sony Music Entertainment"
  • Same parent_company: "Sony Group"
  • Headquarters: "New York" vs "New York City" — semantically equivalent

Result: Auto-merged without human intervention. The golden entity preserves both source records.

Scenario 3: "Coachella" vs Full Festival Name — AI Auto-Merge

# Short name from ticketing platform
curl -X POST https://merge-ai.app/v1/entities \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Venue",
    "attributes": {
      "name": "Coachella",
      "city": "Indio",
      "capacity": "125000",
      "venue_type": "Festival"
    },
    "source": "ticketmaster"
  }'

The existing record has name: "Coachella Valley Music and Arts Festival". The ticketmaster record uses the shorthand "Coachella." The AI recognizes the substring match plus identical city, capacity, and venue_type — auto-merge with confidence 0.9:

{
  "entity_id": "ent_ff224b4f-a424-4d6a-a35c-ec24cd13e8bc",
  "name": "Coachella",
  "confidence_score": "0.9",
  "source_count": 2,
  "sources": [
    { "source_system": "music_db", "name": "Coachella Valley Music and Arts Festival" },
    { "source_system": "ticketmaster", "name": "Coachella" }
  ]
}

Reviews page showing agentic AI resolution decisions

The Three-Tier Resolution Strategy

These scenarios demonstrate Merge's layered approach:

┌─────────────────────────────────────────────────────────────┐
│  Tier 1: Deterministic (Identity Match)                     │
│  external_id exact match → instant auto-merge               │
│  Examples: Weeknd SPOT-1Xyo, Jay-Z SPOT-3nFk               │
│  Speed: <1ms | Confidence: 100%                             │
├─────────────────────────────────────────────────────────────┤
│  Tier 2: AI High-Confidence Auto-Merge                      │
│  Strong multi-signal match → auto-merge                     │
│  Examples: Sony Music/Entertainment, Coachella/full name    │
│  Speed: ~50ms | Confidence: >85%                            │
├─────────────────────────────────────────────────────────────┤
│  Tier 3: AI Review Required                                 │
│  Ambiguous match → human review queue                       │
│  Examples: Gorillaz/Gorillas (could be typo or diff band)   │
│  Speed: human-dependent | Confidence: 50-85%                │
└─────────────────────────────────────────────────────────────┘

Force Merge: Manual Override for Known Duplicates

Sometimes you discover duplicates through domain knowledge that automated systems can't infer. Perhaps your catalog team knows that two label entries are the same entity operating under different names in different territories.

Merge provides a force-merge API for these cases:

# Force merge: absorb entity B into entity A
curl -X POST https://merge-ai.app/v1/entities/{primary_entity_id}/merge/{secondary_entity_id} \
  -H "X-API-Key: YOUR_API_KEY"

{
  "status": "queued",
  "merged_into": "ent_primary_id",
  "from": "ent_secondary_id"
}

The merge is queued and processed asynchronously. After completion:

  • The surviving entity absorbs all source records from the merged entity
  • All relationships from the merged entity transfer to the survivor
  • The old entity ID creates a redirect to the new canonical entity
  • Source count increases, preserving full data lineage

Force merge is also useful for accepting review-queue items programmatically:

# Accept a pending review (equivalent to force merge via review)
curl -X POST https://merge-ai.app/v1/reviews/{review_id}/accept \
  -H "X-API-Key: YOUR_API_KEY"

{
  "action": "merge",
  "status": "merge",
  "target_entity_id": "ent_9bd39123-4899-434e-b948-ca6efbb06cb9",
  "source_record_id": "src_cb450143-9d94-47c2-bfdf-64bae708207d"
}

Relationship Traversal: Discovering Hidden Connections

The real power of entity resolution combined with relationships is graph traversal. A single 3-hop query from The Weeknd reveals an entire constellation of connected entities that would be invisible in any flat database.

curl "https://merge-ai.app/v1/entities/ent_246d0a3e-9796-459a-b8c2-83787a4582fa/graph?hops=3" \
  -H "X-API-Key: YOUR_API_KEY"

What 3 Hops from The Weeknd Reveals

The query returns 11 nodes and 23 edges — a rich subgraph of the music industry:

Hop 1 — Direct connections:

  • XO Records (signed_to) — his record label
  • Coachella (performed_at) — his festival performance
  • After Hours (created_by) — his 2020 album
  • Dawn FM (created_by) — his 2022 album

Hop 2 — One step removed:

  • Drake (signed_to → XO Records) — labelmate connection
  • Kendrick Lamar (performed_at → Coachella) — same festival
  • Take Care (released_on → XO Records) — Drake's album on same label
  • Interscope Records (Kendrick's label)

Hop 3 — Two steps removed:

  • Madison Square Garden (Drake → performed_at) — Drake's venue
  • DAMN. (Kendrick → created_by) — Kendrick's album
  • More album-label relationships completing the picture

3-hop graph visualization from The Weeknd showing labelmates and co-performers

Graph Structure: Labelmate and Venue Connections

The traversal reveals two types of non-obvious connections:

Labelmate discovery (Weeknd → XO Records → Drake):

The Weeknd ──signed_to──→ XO Records ←──signed_to── Drake
                              │
                    released_on ← Take Care
                    released_on ← After Hours
                    released_on ← Dawn FM

Shared venue discovery (Weeknd → Coachella ← Kendrick):

The Weeknd ──performed_at──→ Coachella ←──performed_at── Kendrick Lamar
                                                              │
                                                    signed_to → Interscope
                                                    created_by ← DAMN.

Cross-venue connection (Drake → MSG ← Jay-Z): From Jay-Z's 2-hop graph, we can also see:

Jay-Z ──performed_at──→ Madison Square Garden ←──performed_at── Drake
  │                                                                │
  └── signed_to → Roc Nation                    signed_to → XO Records
  └── created_by ← 4:44, The Blueprint         created_by ← Take Care

These traversal patterns enable queries like:

  • "Which artists share a label with The Weeknd?" → Drake (both on XO Records)
  • "Who else performed at Coachella?" → Kendrick Lamar
  • "What venues connect Jay-Z and Drake?" → Madison Square Garden
  • "Show me all albums released on XO Records" → After Hours, Dawn FM, Take Care

Search: Typo Tolerance and Cross-Entity Discovery

Real users misspell artist names, use nicknames, or type partial queries. Merge's search handles all of these gracefully using edit-distance algorithms and phonetic matching.

Exact Match: "Weeknd"

curl "https://merge-ai.app/v1/entities/search?q=Weeknd" \
  -H "X-API-Key: YOUR_API_KEY"

{
  "results": [
    {
      "entity_id": "ent_246d0a3e-9796-459a-b8c2-83787a4582fa",
      "score": 1,
      "source": {
        "entity_type": "Artist",
        "name": "The Weeknd",
        "source_count": 2,
        "confidence_score": 1,
        "attributes": {
          "external_id": "SPOT-1Xyo",
          "genre": "R&B/Pop",
          "name": "The Weeknd",
          "origin": "Toronto",
          "active_since": "2009"
        }
      },
      "match_signals": ["lexical"]
    }
  ]
}

Note that the result shows source_count: 2 — confirming this is the merged entity combining Spotify and Apple Music data.

Search results for "Weeknd" showing the unified entity with 2 sources

Typo Handling: "Kendrik Lamarr"

What happens when a user types "Kendrik Lamarr" — misspelling both the first name (missing a 'c') and the last name (double 'r', wrong spelling)?

curl "https://merge-ai.app/v1/entities/search?q=Kendrik+Lamarr" \
  -H "X-API-Key: YOUR_API_KEY"

{
  "results": [
    {
      "entity_id": "ent_bbae599a-489a-4feb-a68e-8a629dd9f273",
      "score": 0.85,
      "source": {
        "entity_type": "Artist",
        "name": "Kendrick Lamar",
        "source_count": 1,
        "attributes": {
          "external_id": "SPOT-2YZy",
          "genre": "Hip-Hop",
          "name": "Kendrick Lamar",
          "origin": "Compton",
          "active_since": "2003"
        }
      },
      "match_signals": ["lexical"]
    }
  ]
}

Despite two typos in the query, Merge correctly identifies "Kendrick Lamar" as the intended result. The edit-distance matching handles character insertions, deletions, and substitutions — critical for building search interfaces where users type quickly and make mistakes.

Search results for "Kendrik Lamarr" (typo) correctly finding Kendrick Lamar

Search Capabilities

Feature Example Behavior
Exact name q=Drake Direct lexical match, score=1
Partial match q=Weeknd Substring matching in "The Weeknd"
Double typo q=Kendrik Lamarr Edit-distance correction finds "Kendrick Lamar"
Album search q=After Hours Cross-entity type discovery
Entity filter q=Coldplay&entity_type=Artist Scoped to specific type

Clean Master Data: The End State

After all ingestion and resolution processing, here's what our music master data graph looks like:

Final dashboard showing complete resolution summary

Analytics Summary

curl https://merge-ai.app/v1/analytics/summary \
  -H "X-API-Key: YOUR_API_KEY"

{
  "creates": 24,
  "decisions": 30,
  "merges": 5,
  "reviews": 1,
  "reviews_accepted": 1,
  "reviews_rejected": 0,
  "pending_reviews": 0,
  "feedback_accepted": 1
}

What These Numbers Mean

  • 24 source records ingested — from 5 different source systems (spotify, apple-music, tidal, music_db, fan-wiki, ticketmaster, wikipedia)
  • 30 resolution decisions — every record evaluated against the existing entity graph
  • 5 merges performed — combining duplicates into golden entities
  • 1 review — only one case (Gorillaz/Gorillas) required human judgment
  • 0 pending — all resolution work is complete, queue is clear

The five merges break down as:

  1. The Weeknd: Spotify + Apple Music (identity auto-merge)
  2. Jay-Z: Spotify + Tidal (identity auto-merge)
  3. Sony Music: music_db + Wikipedia (AI auto-merge)
  4. Coachella: music_db + Ticketmaster (AI auto-merge)
  5. Gorillaz: music_db + fan-wiki (human review → accepted)

Resolution Summary Table

Entity Type Sources Resolution Method Key Signal
The Weeknd Artist 2 Identity auto-merge SPOT-1Xyo matched across Spotify + Apple Music
Jay-Z / Jay Z Artist 2 Identity auto-merge SPOT-3nFk matched across Spotify + Tidal
Gorillaz / Gorillas Artist 2 AI → Review → Accepted name_sim=0.72, all attributes identical
Sony Music Entertainment Label 2 AI auto-merge Substring match + same parent_company
Coachella Venue 2 AI auto-merge Substring + same city/capacity/type
Kendrick Lamar Artist 1 — Single source, no merge needed
Billie Eilish Artist 1 — Single source
Coldplay Artist 1 — Single source
Drake Artist 1 — Single source
XO Records Label 1 — Single source
Interscope Records Label 1 — Single source
Parlophone Records Label 1 — Single source
Roc Nation Label 1 — Single source
Madison Square Garden Venue 1 — Single source
Glastonbury Festival Venue 1 — Single source
Wembley Stadium Venue 1 — Single source
After Hours Album 1 — Single source
Dawn FM Album 1 — Single source
DAMN. Album 1 — Single source
4:44 Album 1 — Single source
Happier Than Ever Album 1 — Single source
A Head Full of Dreams Album 1 — Single source
Take Care Album 1 — Single source
The Blueprint Album 1 — Single source

Tips for Music Industry Data Pipelines

1. Use Platform IDs as Identity Keys

Every major music platform assigns stable identifiers: Spotify URIs, Apple Music IDs, ISRC codes for recordings, UPC codes for releases. Map these to your external_id field and mark it identity: true. This gives you instant, deterministic resolution for the majority of your catalog — no AI inference overhead.

2. Design Relationships for Discovery Use Cases

Think about what questions your product needs to answer:

  • "Who else is on this label?" → signed_to relationship
  • "Where has this artist performed?" → performed_at relationship
  • "What albums connect these two artists?" → Multi-hop through created_by + released_on
  • "Show me the entire roster for this festival" → Traverse from Venue inward

Design your relationship schema around these queries.

3. Handle Name Variations at the Source Level

Music artists intentionally use non-standard names: "The Weeknd" (missing 'e'), "Gorillaz" (intentional 'z'), "deadmau5" (leetspeak). Don't normalize these — let the identity key do the matching work. The AI layer handles spelling variations without needing preprocessing.

4. Leverage Multi-Source Confidence

When 3 platforms agree that an entity exists with a specific external ID, that's higher confidence than a single source. Monitor source_count on your golden entities. Entities with only one source may need additional verification before being surfaced in production features.

5. Monitor the Review Queue for Schema Issues

If your review queue grows faster than your team can process it:

  • Increase external_id coverage across source feeds
  • Consider adding more identity fields (ISRC codes for recordings, MusicBrainz IDs)
  • Tune confidence thresholds based on false-positive/false-negative rates

6. Use Graph Traversal for Playlist and Recommendation Features

The relationship graph enables recommendation logic that goes beyond simple collaborative filtering:

  • "Fans of The Weeknd might like Drake" (same label: XO Records)
  • "Artists who performed at Coachella" (venue-based grouping)
  • "Albums connected to this label's roster" (label → artist → album traversal)

7. Plan for Splits

Sometimes merges are wrong. An AI might incorrectly merge "Gorillaz" (the virtual band) with a real band called "Gorillas." Merge's split API lets you undo these:

curl -X POST https://merge-ai.app/v1/entities/{entity_id}/split \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "source_id": "src_to_separate" }'

8. Set Up Webhooks for Real-Time Catalog Updates

Push resolution events to downstream systems (your search index, recommendation engine, or rights management platform):

curl -X POST https://merge-ai.app/v1/webhooks \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://your-app.com/hooks/entity-events",
    "events": ["entity.merged", "entity.created", "review.pending"]
  }'

9. Use Semantic Search for Catalog Discovery

Beyond typo-tolerant lexical search, Merge supports semantic search for natural language queries:

curl "https://merge-ai.app/v1/entities/semantic?q=Toronto+hip+hop+artists" \
  -H "X-API-Key: YOUR_API_KEY"

This enables product features like "artists similar to..." or "music from this region" without building custom classification systems.

10. Export for Compliance and Auditing

Music industry data carries rights implications. Merge's full lineage tracking means you can always trace a golden entity back to its original source records — critical for royalty calculations, licensing disputes, and regulatory compliance:

curl https://merge-ai.app/v1/tenant/export \
  -H "X-API-Key: YOUR_API_KEY"

Conclusion

We started with 24 raw records scattered across seven different source systems — Spotify, Apple Music, Tidal, a music database, a fan wiki, Ticketmaster, and Wikipedia. Each system had its own naming conventions, metadata schemas, and levels of completeness.

Through Merge's three-tier resolution engine, we produced a clean music master data graph with:

  • Golden entities deduplicated from fragmented multi-source inputs
  • 4 relationship types creating a traversable multi-hop graph
  • 11 connected nodes visible from a single 3-hop query starting at The Weeknd
  • 23 relationship edges linking artists, albums, labels, and venues
  • Zero false merges — the review system caught the one ambiguous case (Gorillaz/Gorillas)
  • Full lineage — every golden entity traces back to its original source records

The music industry's metadata problem is a microcosm of the broader entity resolution challenge. Whether you're building a streaming platform, a rights management system, a concert recommendation engine, or an artist analytics dashboard, the pattern is the same: define identity keys for deterministic matching, let AI handle the uncertain middle ground, keep humans in the loop for genuine ambiguity, and connect everything with relationships for graph-powered discovery.

Merge handles all of this through a single API. Schemas in, records in, golden entities and a traversable master data graph out.

Ready to build your own music master data graph? Sign up at merge-ai.app and start resolving entities in minutes.

Built with Merge — Entity resolution and master data graph platform for multi-source data.

Start free All solutions