Solution · E-commerce

Agentic AI Master Data Management for E-Commerce with Merge: From Fragmented Product Listings to Clean Master Catalog

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

Dashboard showing 23 entities created and 15 merges performed

The Multi-Marketplace Product Data Problem

The same product appears on Amazon, eBay, Walmart, Best Buy, and the brand's own direct-to-consumer site. Each marketplace formats the listing differently. Amazon lists it as "Apple iPhone 15 Pro 256GB Space Black." Best Buy calls it "Apple iPhone15 Pro." A third-party eBay seller just writes "iPhone 15 Pro 256 GB." They're all the same device with the same manufacturer SKU, but your catalog sees three different products.

Multiply this across thousands of SKUs, hundreds of sellers, and dozens of category taxonomies, and you're looking at a product data catastrophe. Duplicate listings inflate inventory counts, distort pricing analytics, fragment customer reviews, and break recommendation engines. Traditional deduplication approaches — manual reconciliation, rigid UPC matching, or simple string comparison — can't keep up with the velocity and variety of modern e-commerce data.

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

Ingests product records from multiple marketplaces with different naming conventions
Automatically merges records that share a verified SKU (identity key)
Uses agentic AI to evaluate uncertain matches and route them for human review
Creates a traversable relationship graph connecting products, brands, sellers, and categories
Handles typo-tolerant search for real-time product discovery

By the end, you'll see how 23 raw source records become a clean, interconnected product catalog — with full provenance tracking back to every original listing.

Schema Design: The Foundation of Smart Resolution

Before ingesting any data, we need to tell Merge what our entities look like and how to resolve duplicates. The key concept here is the identity attribute — a field marked with identity: true that triggers deterministic auto-merge when values match exactly.

Entity Schemas

We define four entity types. The Product schema includes an identity attribute on SKU:

# Create the Product schema with SKU as 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": "Product",
    "attributes": [
      { "name": "name", "type": "string", "required": true },
      {
        "name": "sku",
        "type": "string",
        "identity": true,
        "weight": 1,
        "resolution_role": "deterministic",
        "matching_strategy": "exact"
      },
      { "name": "category", "type": "string" },
      { "name": "price_range", "type": "string" }
    ]
  }'

# Create the Brand schema
curl -X POST https://merge-ai.app/v1/schemas \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Brand",
    "attributes": [
      { "name": "name", "type": "string", "required": true },
      { "name": "country_of_origin", "type": "string" },
      { "name": "website", "type": "string" }
    ]
  }'

# Create the Seller schema
curl -X POST https://merge-ai.app/v1/schemas \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Seller",
    "attributes": [
      { "name": "name", "type": "string", "required": true },
      { "name": "marketplace", "type": "string" },
      { "name": "rating", "type": "string" }
    ]
  }'

# Create the Category schema
curl -X POST https://merge-ai.app/v1/schemas \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Category",
    "attributes": [
      { "name": "name", "type": "string", "required": true },
      { "name": "parent_category", "type": "string" }
    ]
  }'

Schema list showing Product with identity:true on SKU

Why SKU is the Identity Key

The identity: true flag on sku tells Merge: "If two product records share the same SKU value, they are definitively the same product — merge them automatically, no questions asked."

SKU is the right choice for an e-commerce identity key because it's the manufacturer's definitive product code. Unlike listing titles (which vary wildly across marketplaces), UPCs (which some sellers omit), or internal IDs (which are marketplace-specific), the manufacturer SKU is a universal reference that transcends any single platform. When Amazon lists a product with sku: "APPLE-IP15P" and Best Buy sends the same code, Merge knows instantly they're the same product — regardless of how differently the listing title is formatted.

The resolution configuration breaks down as:

Parameter	Value	Purpose
`identity`	`true`	Marks SKU as a source-of-truth identifier
`weight`	`1`	Maximum influence on matching score
`resolution_role`	`deterministic`	Exact match triggers automatic merge
`matching_strategy`	`exact`	No approximate matching — values must be identical

Relationships: Connecting Your Master Data

Entities in isolation are useful, but the real power comes from connecting them. We define four relationship types that create a multi-hop traversable graph:

# Product made_by Brand
curl -X POST https://merge-ai.app/v1/relationships \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "relationship_type": "made_by",
    "from_entity_type": "Product",
    "to_entity_type": "Brand"
  }'

# Product sold_by Seller
curl -X POST https://merge-ai.app/v1/relationships \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "relationship_type": "sold_by",
    "from_entity_type": "Product",
    "to_entity_type": "Seller"
  }'

# Product belongs_to Category
curl -X POST https://merge-ai.app/v1/relationships \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "relationship_type": "belongs_to",
    "from_entity_type": "Product",
    "to_entity_type": "Category"
  }'

# Seller operates_on Category
curl -X POST https://merge-ai.app/v1/relationships \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "relationship_type": "operates_on",
    "from_entity_type": "Seller",
    "to_entity_type": "Category"
  }'

These four relationship types create a graph where you can traverse from any node outward:

Brand ← made_by ← Product → belongs_to → Category
                      ↓                      ↑
                   sold_by               operates_on
                      ↓                      ↑
                    Seller ─────────────────────

Multi-Hop Traversal Power

The relationship design enables powerful multi-hop queries. Starting from a single product like "iPhone 15 Pro," a 3-hop traversal reveals:

Product (iPhone) → Brand (Apple) → Product (AirPods Max) → Category (Headphones)
                                  → Product (MacBook Pro) → Seller (GadgetZone)
                 → Seller (TechWarehouse) → Category (Electronics)
                                           → Product (Galaxy S24)
                 → Category (Smartphones) → Product (Galaxy S24) → Brand (Samsung)

This graph enables questions like: "What other products does the same seller carry?" or "What categories does this brand participate in?" or "Which sellers compete in the same category?" — all from a single traversal query.

Data Loading: Ingesting Multi-Source Records

Now the fun part. We load records from multiple sources, each representing how different marketplaces and data providers format the same products.

Categories — The Taxonomy Foundation

# Parent category
curl -X POST https://merge-ai.app/v1/entities \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Category",
    "source_system": "catalog",
    "attributes": {
      "name": "Electronics"
    }
  }'

# Child categories with parent references
curl -X POST https://merge-ai.app/v1/entities \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Category",
    "source_system": "catalog",
    "attributes": {
      "name": "Smartphones",
      "parent_category": "Electronics"
    }
  }'

curl -X POST https://merge-ai.app/v1/entities \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Category",
    "source_system": "catalog",
    "attributes": {
      "name": "Headphones",
      "parent_category": "Electronics"
    }
  }'

curl -X POST https://merge-ai.app/v1/entities \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Category",
    "source_system": "catalog",
    "attributes": {
      "name": "Footwear"
    }
  }'

Brands — The Manufacturers

curl -X POST https://merge-ai.app/v1/entities \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Brand",
    "source_system": "official",
    "attributes": {
      "name": "Apple",
      "country_of_origin": "United States",
      "website": "apple.com"
    }
  }'

curl -X POST https://merge-ai.app/v1/entities \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Brand",
    "source_system": "official",
    "attributes": {
      "name": "Samsung",
      "country_of_origin": "South Korea",
      "website": "samsung.com"
    }
  }'

curl -X POST https://merge-ai.app/v1/entities \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Brand",
    "source_system": "official",
    "attributes": {
      "name": "Sony",
      "country_of_origin": "Japan",
      "website": "sony.com"
    }
  }'

curl -X POST https://merge-ai.app/v1/entities \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Brand",
    "source_system": "official",
    "attributes": {
      "name": "Nike",
      "country_of_origin": "United States",
      "website": "nike.com"
    }
  }'

curl -X POST https://merge-ai.app/v1/entities \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Brand",
    "source_system": "official",
    "attributes": {
      "name": "Bose",
      "country_of_origin": "United States",
      "website": "bose.com"
    }
  }'

Sellers — The Marketplace Vendors

curl -X POST https://merge-ai.app/v1/entities \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Seller",
    "source_system": "marketplace",
    "attributes": {
      "name": "TechWarehouse",
      "marketplace": "Amazon",
      "rating": "4.8"
    },
    "relationships": [
      { "relationship_type": "operates_on", "to_entity_id": "<electronics_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": "Seller",
    "source_system": "marketplace",
    "attributes": {
      "name": "GadgetZone",
      "marketplace": "eBay",
      "rating": "4.6"
    },
    "relationships": [
      { "relationship_type": "operates_on", "to_entity_id": "<electronics_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": "Seller",
    "source_system": "marketplace",
    "attributes": {
      "name": "AudioHub",
      "marketplace": "Amazon",
      "rating": "4.9"
    },
    "relationships": [
      { "relationship_type": "operates_on", "to_entity_id": "<headphones_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": "Seller",
    "source_system": "marketplace",
    "attributes": {
      "name": "SneakerSpot",
      "marketplace": "StockX",
      "rating": "4.7"
    },
    "relationships": [
      { "relationship_type": "operates_on", "to_entity_id": "<footwear_id>" }
    ]
  }'

Products — The Core Catalog with SKU and Relationships

Each product record includes its SKU identity key and relationships to its brand, seller, and category:

# iPhone 15 Pro → Apple + TechWarehouse + Smartphones
curl -X POST https://merge-ai.app/v1/entities \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Product",
    "source_system": "amazon",
    "attributes": {
      "name": "Apple iPhone 15 Pro 256GB Space Black",
      "sku": "APPLE-IP15P",
      "category": "Smartphones",
      "price_range": "$999-$1199"
    },
    "relationships": [
      { "relationship_type": "made_by", "to_entity_id": "<apple_brand_id>" },
      { "relationship_type": "sold_by", "to_entity_id": "<techwarehouse_id>" },
      { "relationship_type": "belongs_to", "to_entity_id": "<smartphones_id>" }
    ]
  }'

# Galaxy S24 Ultra → Samsung + TechWarehouse + Smartphones
curl -X POST https://merge-ai.app/v1/entities \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Product",
    "source_system": "amazon",
    "attributes": {
      "name": "Samsung Galaxy S24 Ultra 256GB",
      "sku": "SAM-GS24U",
      "category": "Smartphones",
      "price_range": "$1199-$1419"
    },
    "relationships": [
      { "relationship_type": "made_by", "to_entity_id": "<samsung_brand_id>" },
      { "relationship_type": "sold_by", "to_entity_id": "<techwarehouse_id>" },
      { "relationship_type": "belongs_to", "to_entity_id": "<smartphones_id>" }
    ]
  }'

# Sony WH-1000XM5 → Sony + AudioHub + Headphones
curl -X POST https://merge-ai.app/v1/entities \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Product",
    "source_system": "amazon",
    "attributes": {
      "name": "Sony WH-1000XM5 Wireless Headphones",
      "sku": "SONY-WH1000",
      "category": "Headphones",
      "price_range": "$348-$399"
    },
    "relationships": [
      { "relationship_type": "made_by", "to_entity_id": "<sony_brand_id>" },
      { "relationship_type": "sold_by", "to_entity_id": "<audiohub_id>" },
      { "relationship_type": "belongs_to", "to_entity_id": "<headphones_id>" }
    ]
  }'

# Apple AirPods Max → Apple + AudioHub + Headphones
curl -X POST https://merge-ai.app/v1/entities \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Product",
    "source_system": "amazon",
    "attributes": {
      "name": "Apple AirPods Max",
      "sku": "APPLE-APM",
      "category": "Headphones",
      "price_range": "$449-$549"
    },
    "relationships": [
      { "relationship_type": "made_by", "to_entity_id": "<apple_brand_id>" },
      { "relationship_type": "sold_by", "to_entity_id": "<audiohub_id>" },
      { "relationship_type": "belongs_to", "to_entity_id": "<headphones_id>" }
    ]
  }'

# Nike Air Max 90 → Nike + SneakerSpot + Footwear
curl -X POST https://merge-ai.app/v1/entities \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Product",
    "source_system": "stockx",
    "attributes": {
      "name": "Nike Air Max 90",
      "sku": "NIKE-AM90",
      "category": "Footwear",
      "price_range": "$130-$160"
    },
    "relationships": [
      { "relationship_type": "made_by", "to_entity_id": "<nike_brand_id>" },
      { "relationship_type": "sold_by", "to_entity_id": "<sneakerspot_id>" },
      { "relationship_type": "belongs_to", "to_entity_id": "<footwear_id>" }
    ]
  }'

# MacBook Pro 14-inch → Apple + GadgetZone + Electronics
curl -X POST https://merge-ai.app/v1/entities \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Product",
    "source_system": "apple-store",
    "attributes": {
      "name": "MacBook Pro 14-inch M3",
      "sku": "APPLE-MBP14",
      "category": "Electronics",
      "price_range": "$1599-$2499"
    },
    "relationships": [
      { "relationship_type": "made_by", "to_entity_id": "<apple_brand_id>" },
      { "relationship_type": "sold_by", "to_entity_id": "<gadgetzone_id>" },
      { "relationship_type": "belongs_to", "to_entity_id": "<electronics_id>" }
    ]
  }'

Entity list showing all ingested records across types

Identity-Based Auto-Merge: The iPhone Case Study

Here's where Merge's resolution engine shines. After establishing the iPhone 15 Pro as a product with SKU APPLE-IP15P, we ingest the same product from two additional marketplace sources — each with a different listing name but the same SKU.

Ingesting Duplicate Listings

# Source 2: Same SKU, slightly different name format (Amazon variant)
curl -X POST https://merge-ai.app/v1/entities \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Product",
    "source_system": "amazon",
    "attributes": {
      "name": "iPhone 15 Pro 256GB Space Black",
      "sku": "APPLE-IP15P",
      "category": "Smartphones",
      "price_range": "$999-$1099"
    }
  }'

# Source 3: Same SKU from Best Buy — compressed name format
curl -X POST https://merge-ai.app/v1/entities \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Product",
    "source_system": "bestbuy",
    "attributes": {
      "name": "Apple iPhone15 Pro",
      "sku": "APPLE-IP15P",
      "category": "Smartphones",
      "price_range": "$999-$1199"
    }
  }'

What Merge Resolved Automatically

The first two records both carry sku: "APPLE-IP15P". Because the Product schema marks sku with identity: true, Merge immediately recognized them as the same product and merged them — no AI evaluation needed, no human review required.

The third record from Best Buy also shares the SKU, but its name format differs significantly ("Apple iPhone15 Pro" vs "Apple iPhone 15 Pro 256GB Space Black"). The system detected the identity match but flagged the name discrepancy for review.

After review acceptance, the golden entity now contains all source records:

# Check iPhone's source records after all merges
curl https://merge-ai.app/v1/entities/ent_42c9a85a-1500-41d4-a7ba-1f5420c9220b/sources \
  -H "X-API-Key: YOUR_API_KEY"

Response showing 4 merged sources:

{
  "sources": [
    {
      "raw": "{\"category\":\"Smartphones\",\"name\":\"Apple iPhone 15 Pro 256GB Space Black\",\"price_range\":\"$999-$1199\",\"sku\":\"APPLE-IP15P\"}",
      "source_id": "src_decb5443-2afd-4582-a82a-6abdd88ba20f",
      "source_system": "amazon"
    },
    {
      "raw": "{\"category\":\"Smartphones\",\"name\":\"Apple iPhone 15 Pro 256GB Space Black\",\"price_range\":\"$999-$1199\",\"sku\":\"APPLE-IP15P\"}",
      "source_id": "src_6681818c-66c3-4530-9610-f9babdf68aa9",
      "source_system": "amazon"
    },
    {
      "raw": "{\"category\":\"Smartphones\",\"name\":\"iPhone 15 Pro 256GB Space Black\",\"price_range\":\"$999-$1099\",\"sku\":\"APPLE-IP15P\"}",
      "source_id": "src_adfb351f-e129-48cb-8ed3-e855b0e9102c",
      "source_system": "amazon"
    },
    {
      "raw": "{\"category\":\"Smartphones\",\"name\":\"Apple iPhone15 Pro\",\"price_range\":\"$999-$1199\",\"sku\":\"APPLE-IP15P\"}",
      "source_id": "src_99a03e07-93b4-4828-8885-26b77c964210",
      "source_system": "bestbuy"
    }
  ]
}

iPhone entity detail showing 4 merged source records from different marketplaces

The Resolution Flow

Here's how each iPhone record was processed:

Source	Listing Name	SKU	Resolution Path
amazon	Apple iPhone 15 Pro 256GB Space Black	APPLE-IP15P	Created new entity
amazon	Apple iPhone 15 Pro 256GB Space Black	APPLE-IP15P	Identity match → auto-merged
amazon	iPhone 15 Pro 256GB Space Black	APPLE-IP15P	Identity match → auto-merged
bestbuy	Apple iPhone15 Pro	APPLE-IP15P	Identity match → review (name too different) → accepted

Four records from two marketplace sources, all correctly unified into one golden product. The shared SKU handled the deterministic cases instantly. The Best Buy record — with its compressed name format missing the storage and color variant — required human confirmation because the name similarity score fell below the auto-merge threshold.

Agentic AI Matching: When Identity Isn't Enough

Not every product record arrives with a clean SKU. Third-party sellers omit it, marketplace APIs don't always expose it, and user-generated listings rarely include it. For these cases, Merge's agentic AI evaluator computes similarity signals across multiple dimensions and makes intelligent routing decisions.

Case 1: "Levi's" vs "Levis" — High-Confidence Auto-Merge

Brand names with punctuation differences are a classic e-commerce problem. We ingested two records:

# Official source
curl -X POST https://merge-ai.app/v1/entities \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Brand",
    "source_system": "official",
    "attributes": {
      "name": "Levi'\''s",
      "country_of_origin": "United States",
      "website": "levis.com"
    }
  }'

# Retailer source (no apostrophe)
curl -X POST https://merge-ai.app/v1/entities \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Brand",
    "source_system": "retailer",
    "attributes": {
      "name": "Levis",
      "country_of_origin": "United States",
      "website": "levi.com"
    }
  }'

The AI evaluator computed:

{
  "comparison_details": {
    "name_sim": 0.967,
    "attr_overlap": 0.988,
    "attr_boost": true
  },
  "confidence_score": 0.72
}

name_sim: 0.967 — "Levi's" vs "Levis" differ by a single apostrophe
attr_overlap: 0.988 — Same country of origin, nearly identical website
Result: Routed to review queue (confidence 0.72 falls in the review band)

After human acceptance, the two Brand records merge into a single "Levis" golden entity with full provenance.

Case 2: "Bose QuietComfort" vs "Bose QC Ultra" — Correctly Separated

These are legitimately different products from the same brand:

# Product 1
curl -X POST https://merge-ai.app/v1/entities \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Product",
    "source_system": "amazon",
    "attributes": {
      "name": "Bose QuietComfort Headphones",
      "category": "Headphones",
      "price_range": "$249-$349"
    }
  }'

# Product 2
curl -X POST https://merge-ai.app/v1/entities \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Product",
    "source_system": "bestbuy",
    "attributes": {
      "name": "Bose QC Ultra Headphones",
      "category": "Headphones",
      "price_range": "$299-$379"
    }
  }'

Despite sharing "Bose" and "Headphones" in the name, the AI recognized that "QuietComfort" and "QC Ultra" are distinct product lines with different price points. Without a shared SKU, there's no identity match, and the name similarity wasn't high enough to trigger even a review. These correctly remained as separate entities.

Case 3: "Samsung Galaxy S24 Ultra" vs "Galaxy S24 Ultra" — AI Merge

This is the classic brand-prefix problem. Walmart includes "Samsung" in the listing title; eBay's seller drops it:

# Walmart listing
curl -X POST https://merge-ai.app/v1/entities \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Product",
    "source_system": "walmart",
    "attributes": {
      "name": "Samsung Galaxy S24 Ultra",
      "category": "Smartphones",
      "price_range": "$1199-$1419"
    }
  }'

# eBay listing (brand prefix dropped)
curl -X POST https://merge-ai.app/v1/entities \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "Product",
    "source_system": "ebay",
    "attributes": {
      "name": "Galaxy S24 Ultra",
      "category": "Smartphones",
      "price_range": "$1099-$1399"
    }
  }'

The existing Galaxy S24 entity already had SKU SAM-GS24U. When the walmart record came in without a SKU but with very high name similarity to "Samsung Galaxy S24 Ultra 256GB," the AI evaluated it and auto-merged it (high confidence from matching category and overlapping price range). The eBay record similarly matched based on the "Galaxy S24 Ultra" substring and shared category.

The Galaxy S24 golden entity now carries 4 source records from amazon, walmart, and ebay:

{
  "sources": [
    { "source_system": "amazon", "name": "Samsung Galaxy S24 Ultra 256GB" },
    { "source_system": "amazon", "name": "Samsung Galaxy S24 Ultra 256GB" },
    { "source_system": "walmart", "name": "Samsung Galaxy S24 Ultra" },
    { "source_system": "ebay", "name": "Galaxy S24 Ultra" }
  ]
}

Reviews panel showing accepted merge decisions

The Three-Tier Resolution Strategy

This demonstrates Merge's three-tier approach:

┌─────────────────────────────────────────────────────┐
│  Tier 1: Deterministic (Identity Match)             │
│  SKU exact match → instant auto-merge               │
│  Speed: <1ms | Confidence: 100%                     │
├─────────────────────────────────────────────────────┤
│  Tier 2: Agentic AI High-Confidence                 │
│  Multi-signal evaluation → auto-merge               │
│  Speed: ~50ms | Confidence: >85%                    │
├─────────────────────────────────────────────────────┤
│  Tier 3: Agentic AI Review Required                 │
│  Uncertain match → human review queue               │
│  Speed: human-dependent | Confidence: 50-85%        │
└─────────────────────────────────────────────────────┘

The agentic AI layer is what distinguishes Merge from simple rule-based deduplication. It doesn't just check string distance — it evaluates attribute concordance, category alignment, price proximity, and contextual signals to make intelligent merge-or-separate decisions. When it's confident, it acts autonomously. When it's uncertain, it asks for help.

Force Merge: Manual Override for Known Duplicates

Sometimes you discover duplicates that the automated system hasn't caught — perhaps because the names differ too much and there's no shared SKU. Merge provides a force-merge API for these cases.

In our dataset, TechWarehouse appeared twice:

TechWarehouse (from marketplace source, Amazon-focused)
Tech Warehouse (from eBay source, with a space in the name)

These are clearly the same seller operating across platforms, but "TechWarehouse" vs "Tech Warehouse" with different marketplace values and ratings meant the system couldn't be certain. A force merge resolves this:

# Force merge: absorb "Tech Warehouse" into "TechWarehouse"
curl -X POST https://merge-ai.app/v1/entities/ent_d2daf211-d202-405d-88ea-e66e8de5d7a3/merge/ent_b140dca8-d534-48be-b53f-4b3775de8bd9 \
  -H "X-API-Key: YOUR_API_KEY"

{
  "from": "ent_b140dca8-d534-48be-b53f-4b3775de8bd9",
  "merged_into": "ent_d2daf211-d202-405d-88ea-e66e8de5d7a3",
  "status": "queued"
}

The merge is queued and processed asynchronously. After completion, the surviving entity ("TechWarehouse") absorbs all source records, relationships, and history from the merged entity. The old entity ID redirects to the new one.

After the force merge, TechWarehouse's source count increases:

curl https://merge-ai.app/v1/entities/ent_d2daf211-d202-405d-88ea-e66e8de5d7a3 \
  -H "X-API-Key: YOUR_API_KEY"

{
  "entity_id": "ent_d2daf211-d202-405d-88ea-e66e8de5d7a3",
  "name": "TechWarehouse",
  "source_count": 3,
  "attributes": "{\"marketplace\":\"Amazon\",\"name\":\"TechWarehouse\",\"rating\":\"4.8\"}",
  "labels": [["Seller"]]
}

The force merge preserves all relationships — any product previously linked via sold_by to "Tech Warehouse" now correctly points to the consolidated TechWarehouse entity.

Relationship Traversal: Exploring Connected Entities

With entities resolved and relationships established, we can traverse the master data graph. A 3-hop query from the iPhone 15 Pro reveals the entire connected product ecosystem:

curl "https://merge-ai.app/v1/entities/ent_42c9a85a-1500-41d4-a7ba-1f5420c9220b/graph?hops=3" \
  -H "X-API-Key: YOUR_API_KEY"

What 3 Hops from iPhone 15 Pro Reveals

Starting from the iPhone and traversing outward three relationship edges:

Hop 1 — Direct connections:

Apple (made_by)
TechWarehouse (sold_by)
Smartphones (belongs_to)

Hop 2 — One step removed:

AirPods Max (Apple ← made_by)
MacBook Pro 14-inch M3 (Apple ← made_by)
Galaxy S24 Ultra (TechWarehouse ← sold_by)
Electronics (TechWarehouse → operates_on)
Galaxy S24 Ultra (Smartphones ← belongs_to)

Hop 3 — Two steps removed:

Headphones (AirPods Max → belongs_to)
AudioHub (AirPods Max → sold_by)
GadgetZone (MacBook Pro → sold_by)
Samsung (Galaxy S24 → made_by)
Electronics (MacBook Pro → belongs_to)

The full graph response includes 12 nodes and 23 edges — a comprehensive view of how e-commerce entities interconnect through just three relationship hops.

{
  "entity_id": "ent_42c9a85a-1500-41d4-a7ba-1f5420c9220b",
  "hops": 3,
  "nodes": [
    { "entity_id": "ent_42c9a85a-...", "name": "Apple iPhone15 Pro", "labels": [["Product"]], "source_count": 4 },
    { "entity_id": "ent_044f34df-...", "name": "Apple", "labels": [["Brand"]] },
    { "entity_id": "ent_d2daf211-...", "name": "TechWarehouse", "labels": [["Seller"]] },
    { "entity_id": "ent_14653539-...", "name": "Smartphones", "labels": [["Category"]] },
    { "entity_id": "ent_76d90921-...", "name": "Apple AirPods Max", "labels": [["Product"]] },
    { "entity_id": "ent_3b686b59-...", "name": "MacBook Pro 14-inch M3", "labels": [["Product"]] },
    { "entity_id": "ent_cec94708-...", "name": "Galaxy S24 Ultra", "labels": [["Product"]] },
    { "entity_id": "ent_24012bbb-...", "name": "Samsung", "labels": [["Brand"]] },
    { "entity_id": "ent_0f2500be-...", "name": "Electronics", "labels": [["Category"]] },
    { "entity_id": "ent_f28ef038-...", "name": "GadgetZone", "labels": [["Seller"]] },
    { "entity_id": "ent_64325349-...", "name": "AudioHub", "labels": [["Seller"]] },
    { "entity_id": "ent_9c5f0684-...", "name": "Headphones", "labels": [["Category"]] }
  ],
  "edges": [
    { "from": "iPhone", "to": "Apple", "type": "made_by" },
    { "from": "iPhone", "to": "TechWarehouse", "type": "sold_by" },
    { "from": "iPhone", "to": "Smartphones", "type": "belongs_to" },
    { "from": "AirPods Max", "to": "Apple", "type": "made_by" },
    { "from": "AirPods Max", "to": "AudioHub", "type": "sold_by" },
    { "from": "AirPods Max", "to": "Headphones", "type": "belongs_to" },
    { "from": "MacBook Pro", "to": "Apple", "type": "made_by" },
    { "from": "MacBook Pro", "to": "GadgetZone", "type": "sold_by" },
    { "from": "MacBook Pro", "to": "Electronics", "type": "belongs_to" },
    { "from": "Galaxy S24", "to": "Samsung", "type": "made_by" },
    { "from": "Galaxy S24", "to": "TechWarehouse", "type": "sold_by" },
    { "from": "Galaxy S24", "to": "Smartphones", "type": "belongs_to" },
    { "from": "TechWarehouse", "to": "Electronics", "type": "operates_on" },
    { "from": "GadgetZone", "to": "Electronics", "type": "operates_on" }
  ]
}

3-hop graph visualization from iPhone 15 Pro showing product constellation

Graph Structure Summary

iPhone 15 Pro (4 sources)
├── made_by → Apple
│   ├── made_by ← AirPods Max
│   │   ├── sold_by → AudioHub
│   │   │   └── operates_on → Headphones
│   │   └── belongs_to → Headphones
│   └── made_by ← MacBook Pro 14-inch M3
│       ├── sold_by → GadgetZone
│       │   └── operates_on → Electronics
│       └── belongs_to → Electronics
├── sold_by → TechWarehouse
│   ├── operates_on → Electronics
│   └── sold_by ← Galaxy S24 Ultra
│       ├── made_by → Samsung
│       └── belongs_to → Smartphones
└── belongs_to → Smartphones
    └── belongs_to ← Galaxy S24 Ultra

This graph enables powerful e-commerce queries like:

"What other products does Apple make?" → AirPods Max, MacBook Pro
"What else does TechWarehouse sell?" → Galaxy S24 Ultra
"What categories share sellers?" → Electronics connects TechWarehouse and GadgetZone
"Cross-sell recommendations for iPhone buyers" → Same brand (AirPods) or same seller (Galaxy S24)

Search: Typo Tolerance and Product Discovery

Merge's search handles the messiness of real-world queries. Shoppers misspell brand names, drop prefixes, and use shorthand. The search engine handles all of these gracefully.

Typo Search: "Samsng Galaxy"

What happens when a user types "Samsng Galaxy" — dropping the 'u' from Samsung?

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

{
  "results": [
    {
      "entity_id": "ent_cec94708-a13b-4abf-839c-13b1379b4d49",
      "score": 1,
      "source": {
        "entity_type": "Product",
        "name": "Galaxy S24 Ultra",
        "source_count": 4,
        "attributes": {
          "name": "Galaxy S24 Ultra",
          "sku": "SAM-GS24U",
          "category": "Smartphones",
          "price_range": "$1099-$1399"
        }
      },
      "match_signals": ["lexical"]
    },
    {
      "entity_id": "ent_24012bbb-a4a4-4878-895d-57bdd648240e",
      "score": 0.836,
      "source": {
        "entity_type": "Brand",
        "name": "Samsung"
      },
      "match_signals": ["lexical"]
    }
  ]
}

Despite the typo ("Samsng" instead of "Samsung"), Merge returns both the Galaxy S24 product and the Samsung brand entity. The search engine uses edit-distance algorithms and n-gram matching to correct the mistake transparently.

Merged Entity Search: "iPhone"

Searching for "iPhone" returns the unified golden entity — not the four separate source records:

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

{
  "results": [
    {
      "entity_id": "ent_42c9a85a-1500-41d4-a7ba-1f5420c9220b",
      "score": 1,
      "source": {
        "entity_type": "Product",
        "name": "Apple iPhone15 Pro",
        "source_count": 4,
        "confidence_score": 0.72,
        "attributes": {
          "name": "Apple iPhone15 Pro",
          "sku": "APPLE-IP15P",
          "category": "Smartphones",
          "price_range": "$999-$1199"
        }
      },
      "match_signals": ["lexical"]
    }
  ]
}

One result. One golden entity. Four source records unified behind it. This is what clean product master data looks like — no duplicate search results confusing the buyer or inflating catalog counts.

Search Capabilities

Feature	Example Query	Behavior
Exact name	`q=AirPods Max`	Direct lexical match
Partial name	`q=MacBook`	Prefix matching
Typo tolerance	`q=Samsng Galaxy`	Edit-distance correction
Entity type filter	`q=Apple&entity_type=Brand`	Scoped to brands only
Attribute search	`attribute=category&value=Headphones`	Field-level lookup
Missing brand prefix	`q=Galaxy S24`	Matches "Samsung Galaxy S24 Ultra"

The Final Picture: Clean Master Data

After all resolution processing, here's what our e-commerce master data graph looks like:

Final dashboard showing completed resolution with analytics

Analytics Summary

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

{
  "creates": 23,
  "merges": 15,
  "decisions": 41,
  "reviews": 2,
  "reviews_accepted": 2,
  "reviews_rejected": 0,
  "feedback_accepted": 2,
  "pending_reviews": 0
}

What These Numbers Tell Us

23 source records ingested from multiple systems (amazon, bestbuy, walmart, ebay, stockx, apple-store, official, retailer, marketplace, catalog)
15 merges performed — combining duplicate listings into golden products
41 resolution decisions — each record evaluated against the existing entity graph
2 reviews — only two cases required human judgment (name format differences)
0 pending — all resolution work is complete

Resolution Summary Table

Entity	Type	Sources	Resolution Method	Notes
Apple iPhone15 Pro	Product	4	Identity (2) + Review (1)	SKU APPLE-IP15P unified Amazon + Best Buy listings
Galaxy S24 Ultra	Product	4	Identity (1) + AI (2)	SKU SAM-GS24U + AI matched Walmart/eBay variants
Sony WH-1000XM5	Product	1	—	Single source, unique SKU
Apple AirPods Max	Product	1	—	Single source, unique SKU
Nike Air Max 90	Product	1	—	Single source, unique SKU
MacBook Pro 14-inch M3	Product	1	—	Single source, unique SKU
Bose QuietComfort	Product	1	—	Correctly separated from QC Ultra (different product)
Bose QC Ultra	Product	1	—	Correctly separated (different price point)
TechWarehouse	Seller	3	Force merge	"TechWarehouse" + "Tech Warehouse" manually unified
GadgetZone	Seller	1	—	Single source
AudioHub	Seller	1	—	Single source
SneakerSpot	Seller	1	—	Single source
Apple	Brand	1	—	Single authoritative source
Samsung	Brand	1	—	Single authoritative source
Sony	Brand	1	—	Single authoritative source
Nike	Brand	1	—	Single authoritative source
Bose	Brand	1	—	Single authoritative source
Levis	Brand	2	AI + Review	"Levi's" vs "Levis" punctuation difference
Electronics	Category	1	—	Root category
Smartphones	Category	1	—	Child of Electronics
Headphones	Category	1	—	Child of Electronics
Footwear	Category	1	—	Standalone category

Tips for Production E-Commerce Data Pipelines

1. Choose SKU as Your Identity Key

In e-commerce, the manufacturer SKU is the most reliable identity anchor. Unlike UPCs (which vary by region), ASINs (Amazon-specific), or listing IDs (marketplace-specific), the manufacturer SKU is a universal code that appears across all channels. Mark it with identity: true and let deterministic matching handle the bulk of deduplication.

2. Handle Missing SKUs Gracefully

Not all sources provide SKUs. Third-party marketplace sellers often omit them, and user-generated listings rarely include them. Design your pipeline to:

Ingest records with or without SKU
Let identity matching handle records that have SKUs
Let agentic AI handle records without SKUs using name similarity, category, and price signals
Route uncertain cases to human review

3. Use Categories for Validation

Category alignment is a strong signal for product matching. If two records share the same category ("Smartphones") and similar names, that's much stronger evidence than name similarity alone. Build your relationship graph to leverage this — the belongs_to relationship creates traversal paths that the resolution engine can use for validation.

4. Model Seller-Category Relationships

The operates_on relationship between Seller and Category enables powerful marketplace intelligence:

"Which sellers compete in the same category?"
"What categories does this seller cover?"
"Find alternative sellers for this product type"

These queries are trivial with graph traversal but nearly impossible with flat relational tables.

5. Monitor Resolution Quality

Watch these metrics in production:

Metric	Healthy Range	Action if Exceeded
Review queue depth	< 50 pending	Add more identity keys or tune thresholds
False merge rate	< 1%	Tighten confidence thresholds
Missed merge rate	< 5%	Loosen thresholds or add attribute signals
Average merge latency	< 100ms	Scale processing infrastructure
Source coverage	> 80% with SKUs	Work with suppliers to include SKUs

6. Build for Cross-Sell and Recommendations

Graph traversal enables recommendation patterns that traditional catalogs can't support:

# Find products from the same brand sold by different sellers
# iPhone → Apple → AirPods Max → AudioHub (different seller than TechWarehouse)
curl "https://merge-ai.app/v1/entities/<iphone_id>/graph?hops=3" \
  -H "X-API-Key: YOUR_API_KEY"

This powers "Customers who bought this also considered..." recommendations by traversing brand, category, and seller connections — without any collaborative filtering or ML model training.

7. Handle Price Range Normalization

Different marketplaces report different prices for the same product. Merge preserves all source records, letting your application layer decide how to present pricing:

Show the lowest available price
Show the price range across all sources
Show marketplace-specific pricing

The golden entity holds the full picture; your UI chooses how to display it.

8. Plan for Product Lifecycle

Products get discontinued, renamed, or superseded. Use Merge's split API when a product entity erroneously combines a current and legacy version:

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_legacy_product_record" }'

9. Use Webhooks for Real-Time Catalog Updates

Set up webhooks to push resolution events to downstream systems — search indexes, recommendation engines, inventory managers:

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-store.com/hooks/catalog-events",
    "events": ["entity.merged", "entity.created", "review.pending"]
  }'

10. Scale with Batch Ingestion

For large catalog imports, use the batch endpoint instead of single-record ingestion:

curl -X POST https://merge-ai.app/v1/entities/batch \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entities": [
      { "entity_type": "Product", "source_system": "feed", "attributes": {...} },
      { "entity_type": "Product", "source_system": "feed", "attributes": {...} },
      ...
    ]
  }'

Batch processing handles thousands of records per request with the same resolution logic applied to each.

Conclusion

We started with 23 raw product records scattered across ten different data sources — each with its own naming conventions, SKU coverage, and completeness levels. Through Merge's three-tier resolution engine, we produced a clean master data graph with:

22 golden entities — deduplicated, enriched, and confidence-scored
4 relationship types — creating a traversable multi-hop product graph
12 connected nodes visible from a single 3-hop query
Zero false merges — the Bose QuietComfort and QC Ultra correctly remained separate
Full lineage — every golden entity traces back to its original marketplace listings

The e-commerce product data domain is a perfect fit for master data graph resolution. Products flow through dozens of channels, each reformatting and abbreviating as they go. Traditional approaches — manual deduplication, rigid UPC matching, or simple string comparison — break down at marketplace scale. You need deterministic matching for records with SKUs, agentic AI for records without them, and human review for the genuinely ambiguous cases.

Merge handles all of this through a single API — no ML models to train, no complex ETL pipelines to maintain, no infrastructure to manage. Define your schemas with identity keys, ingest records from any source, and let the resolution engine produce clean master data with full provenance.

Ready to clean up your product catalog? Sign up at merge-ai.app and start resolving product entities in minutes.

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

Start free All solutions