For merchant-ops teams and feed-tool developers

Catalog Attribute Normalizer — clean, consistent product data from messy multi-source catalogs

Shopify export here, a supplier CSV there, a marketplace scrape somewhere else — three different ideas of what "size" or "material" means, half the products missing attributes entirely. One API call turns that mess into clean, normalized attributes and taxonomy mappings, ready for marketplace listing, PIM/ERP sync, or an agentic-commerce feed.

Request
{
  "tool": "normalize_catalog",
  "input": {
    "products": [{
      "title": "...",
      "description": "...",
      "raw_attributes": { "...": "..." }
    }],
    "target_taxonomies": ["google", "shopify"]
  }
}
Response
{
  "products": [{
    "source_title": "...",
    "category_paths": {
      "google": {
        "path": ["Apparel & Accessories",
          "Clothing", "Shirts & Tops"],
        "leaf_id": null,
        "confidence": 0.9
      },
      "shopify": {
        "path": ["Apparel & Accessories",
          "Clothing", "Tops"],
        "leaf_id": "aa-3-1",
        "confidence": 0.85
      }
    },
    "attributes": {
      "color": "navy",
      "material": "cotton",
      "size": "M"
    }
  }]
}

Attributes are reliable by construction — canonicalizing values already in your input ("Lg" → "L"), not recall. Category classification is best-effort: confidence and a null on the taxonomy's own leaf ID are the honest signal for "worth a quick check," not a confirmed answer every time. We'd rather tell you when we're not sure than guess.

Why this exists

Category-classification APIs will tell you what a product is. They don't touch the messier problem: extracting and standardizing the attributes — color, size, material, unit values — across sources that each spell them differently, or leave them out. The vendors that do take on the broader job are enterprise sales-led — book a demo, annual contract, no self-serve and no public price. We built the self-serve version of that.

Pricing

Free tier is sized to prove the output on a real slice of your catalog, not a toy sample. No credit card required to start.

Free

$0
500 products/month
No card required

A merchant needs to normalize a real catalog slice — hundreds of SKUs — to trust the output at all; a token free tier wouldn't prove anything.

Pay-as-you-go

$0.01/product
No minimum
$0.01 effective

For one-off cleanups or spiky feed-refresh jobs.

Pro

$29/month
5,000 products/month
~$0.0058 effective

Priced below the entry tier of the classification-only APIs on a per-unit basis, while doing strictly more — attributes, not just category.

Against classification-only APIs: that category prices per classification credit on monthly plans, scaling into four- and five-figure enterprise tiers. We're below that per-unit price point while shipping a broader task — full attribute normalization, not just category.
Against enterprise normalization vendors: no public price at all (sales-led), so there's nothing to anchor against directly — only the friction. No self-serve signup is a real gap for any team not big enough to justify a sales cycle.

How it compares

Clean, normalized product attributes and taxonomy mappings from messy multi-source catalogs — titles, descriptions, images in; consistent attributes, units, and category mappings out. The alternatives below are described by category, not by brand: what matters when you're choosing is the shape of the thing — how it's called, what it returns, and what it leaves you to build. Nothing here is hidden to make the paid option look better.

Alternative Why you might still need Catalog Attribute Normalizer
Category-classification APIs Classification only: they return a taxonomy path for a product and stop there. No general attribute extraction, no unit normalization, no dedup — the parts of "clean product data" that actually take the time. Headline accuracy claims in this category are typically published without a stated sample size or test methodology, so there's nothing to check them against.
Enterprise attribute-normalization vendors These do take on the broader job, and do it well, but they're sold rather than shipped: demo request first, pricing on application, commonly a one-year contract, and an API only on the custom top tier. There's no free tier to try the output on your own catalog, and their own accuracy pages tend to make no quantified claim. If you're not big enough to justify a sales cycle, the capability isn't reachable.
Manual cleanup (consultancies and offshore data teams) The default answer for large catalogs, and it works — at a per-SKU cost and a turnaround measured in weeks. It isn't an API, so it can't sit inside a feed refresh, and the normalization decisions live in someone's spreadsheet rather than in a versioned, repeatable mapping.
DIY with a raw LLM call Fastest to stand up, and it fails in a specific way: taxonomy IDs that look valid but don't exist or point at the wrong path, and attributes guessed rather than canonicalized. This tool validates every returned ID against the real taxonomy files, canonicalizes values already present in your input ("Lg" → "L") instead of recalling them, and returns null rather than a fabricated value when it can't resolve one.

Get a key

Free tier: 500 products/month, no card required. Keys are self-serve and shown once.