Does this API fetch data from retailers?

No. It only normalizes JSON payloads you send. It does not call Amazon, Walmart, or other retailer APIs.

Do I need retailer API keys?

No for this API. You obtain product JSON through your own integrations and pass it to POST /normalize or /compare.

What is POST /compare?

After normalization, POST a products array to /compare with an optional queryIntent such as cheapest, best_reviewed, in_stock_only, or exclude_third_party to get rankings and comparison blocks.

Can I combine multiple retailer payloads in one request?

Yes. Send an inputs array; each element has retailerId and payload. You get a merged products array plus per-source results and errors.

What if one retailer payload fails?

Other sources still normalize. Check results and errors for per-source issues.

What is the max request size?

25MB per request for both /normalize and /compare.

No. The service is fully stateless.

Where are pricing and quotas defined?

On RapidAPI: Basic is free with 100 requests per month; Pro is 9.99 dollars per month with 10000 requests; Ultra is 49.99 dollars per month recommended with 100000 requests; Mega is 99.99 dollars per month with 250000 requests. Overage pricing is on the live listing.

Normalize Retail Product Data From Any Retailer Into One Schema

One POST /normalize merges Amazon, Walmart, eBay, Target, Best Buy, Costco, Shopify, and other product JSON into a single canonical product model—merged products array, per-source results and errors, partial success when one payload fails. Add POST /compare for cheapest, best reviewed, and deterministic rankings.

Try Retail Data Normalization API Basic on RapidAPI: 100 requests/month free

Stop maintaining parallel product parsers per retailer. Feed raw catalog or API responses into one normalization layer—same identifiers, price, availability, and reviews shape every time. Ship comparison and analytics features faster without chasing every vendor’s JSON churn.

Real-world use cases

Unify multi-retailer catalog or affiliate feeds into one schema for search, filters, and PDPs.
Power price-comparison and deal apps with normalized prices and availability before your own matching logic.
Batch several retailerId + payload pairs in one request for ETL or nightly merges.
Rank offers with /compare using queryIntent such as cheapest, best_reviewed, or in_stock_only.
Isolate failures when one source is malformed—other retailers still return normalized products.
Route unknown vendors through retailerId: "custom" for best-effort field extraction.

Why not build your own normalizer?

Each marketplace nests price, offers, and media differently
Availability and seller semantics change without notice
Adding a new retailer multiplies edge cases

Centralizing mappings here means you inherit updates when common payload shapes drift.

Who this API helps

E-commerce, marketplaces, and shopping extensions
Price intelligence and competitive analytics teams
Data engineers merging heterogeneous product feeds
Anyone needing deterministic JSON-to-JSON normalization (not scraping)

Before and after normalization

Retailers use different envelopes and field names. The API maps them into one predictable product shape (illustrative).

Before (vendor-style fragment)

{
  "Items": [{ "ASIN": "B0…", "ItemInfo": { "Title": { "DisplayValue": "…" } } }]
}

After (canonical fields)

{
  "id": "amazon:B0…",
  "title": "…",
  "price": { "amount", "currency", "display" },
  "availability": "in_stock",
  "rawSource": { "retailerId": "amazon" }
}

What the API does

POST /normalize — Body includes an inputs array. Each item has retailerId (e.g. amazon, walmart, custom) and payload (raw JSON). Response includes merged products, per-source results, and errors.

POST /compare — Send a normalized products array plus optional queryIntent to obtain price and review comparison blocks and rankings.

This API operates on structured JSON you already have. It does not fetch live listings from retailers.

Retailers: dedicated keys vs custom

The retailerId string selects a normalizer. Well-known merchants use dedicated adapters; unknown labels can use custom for heuristic extraction.

Common retailerId values

Examples with first-class or common paths (not exhaustive):

amazon — catalog / PA-API style items
walmart — items, pricing fields
ebay, target, bestbuy, costco
shopify, google_shopping, etsy, flipkart

Custom and versions

Use retailerId: "custom" for unknown shapes. Some sources accept optional schemaVersion per input when versioned normalizers exist—see the RapidAPI docs for your payload type.

Many additional retailer keys are supported; check the README on the hub or your listing for the full table.

Want a first-class adapter for a retailer? Request it on RapidAPI discussions — include a redacted sample payload and the vendor name.

Request & response schema

Normalize: POST https://retail-data-normalization-comparison.p.rapidapi.com/normalize with Content-Type: application/json, x-rapidapi-key, x-rapidapi-host.

View request schema · View response schema · View error & warning codes

Code	HTTP	Description
`PARSE_ERROR`	`—`	Payload could not be parsed for this retailer
`UNSUPPORTED_FORMAT`	`—`	Retailer payload format not supported
`MISSING_DATA`	`—`	No product items found in payload
`INVALID_PAYLOAD`	`—`	Payload is not a valid object or structure
`SKIPPED`	`—`	Input was skipped (e.g., empty payload)

Field	Type	Description
`inputs[].retailerId`	`string`	Per-item: retailerId
`inputs[].payload`	`any`	Per-item: payload
`inputs[].schemaVersion`	`string`	Per-item: optional schemaVersion
`inputs[].parsingHints`	`object`	Per-item: optional parsingHints

Field	Type	Description
`results[].retailerId`	`string`	Per-item: retailerId
`results[].products`	`array`	Per-item: products
`results[].error`	`any`	Per-item: error
`errors`	`array`	Top-level errors collection
`products[]`	`object`	Merged canonical products (id, identifiers, title, price, availability, reviews, rawSource, …)

Try it in the playground

Pick a sample (normalize or compare), edit JSON, add your RapidAPI key, run. Code snippets below follow the same URL path. The key is sent only to RapidAPI.

RapidAPI Key (required)

Sample request

Loads a template into the JSON editor. Switching samples changes the path (/normalize vs /compare).

Request body (JSON)

Subscribe on RapidAPI for production keys and plan details.

Get code

Snippets use the JSON in the playground and the active path from the sample (/normalize or /compare). Choose a language, refresh after edits, then copy.

Integration time: Under 5 minutes with any HTTP client that can POST JSON and set RapidAPI headers.

Pricing & tiers (RapidAPI)

Built for pipelines that need canonical product JSON across heterogeneous retailers—comparison UIs, warehouses, and analytics.

Current plans on RapidAPI:

Basic

$0/mo

Primary: 100/month

Pro

$9.99/mo

Primary: 10,000/month

Recommended

Ultra

$49.99/mo

Primary: 100,000/month, then $0.003 each

Mega

$99.99/mo

Primary: 250,000/month, then $0.002 each

If RapidAPI pricing or quotas change, the live listing is authoritative.

What to expect

Successful calls return JSON with normalized product data. Use your RapidAPI key on every request. Stateless: no payload storage. See RapidAPI docs for full request and response shapes including /compare.

About this API

Who should use this API

Teams that need one schema for product data across retailers: e-commerce platforms, comparison tools, analytics pipelines, and marketplace integrators.

Also known as

Retail JSON normalizer, multi-retailer product API, catalog unification API, Amazon Walmart eBay normalizer.

Retail Data Normalization & Comparison API

Standardize and compare retail product data across Amazon, Walmart, eBay, Target, Best Buy, Costco, Shopify, Google Shopping, Etsy, and more. Send an inputs array with retailerId and raw payload; receive merged products, per-source results, and errors. Optional /compare returns rankings and comparison blocks. Stateless, up to 25MB per request, partial success per source.

Frequently asked questions

No. It only normalizes JSON payloads you send. It does not call Amazon, Walmart, eBay, or other retailer APIs.
No for this API. You use your RapidAPI key here. You obtain product JSON through your own integrations.
Send a normalized products array with optional queryIntent (cheapest, best_reviewed, in_stock_only, exclude_third_party) to get price and review comparison summaries and rankings.
Yes. Use an inputs array; each element has retailerId and payload. You get one merged products list plus per-source results.
Other sources still normalize. Inspect results[].error and the top-level errors array for details.
25MB per request for /normalize and /compare.
No. The service is fully stateless.
On RapidAPI: Basic is free with 100 requests/month; Pro ($9.99/mo) includes 10,000/month; Ultra ($49.99/mo, recommended) includes 100,000/month; Mega ($99.99/mo) includes 250,000/month—with overage rules as shown on the listing.

Browse all APIs in the catalog →