# v3.0.0
Source: https://docs.kicks.dev/changelog/v3.0
Changelog from 2025-01-27 to 2025-02-13
# Changelog v3.0.7 (2025-02-13)
**New features**
* Added the [Get price offers (GOAT)](/api-reference-v3/realtime/goat-offers) endpoint to the Realtime API, allowing to gather price offers for a GOAT product.
**Improvements**
* Added `description`, `brand`, `model`, `sizes` to the response for GOAT products.
**Migration**
* Migrated [Product Detail v2](/api-reference-v2/endpoint/product) to v3 database. The response structure is left unchanged, however, `blurhash`, `gender` and `weekly_gmv` will always return null.
# Changelog v3.0.6 (2025-02-12)
**New features**
* Added the `category` parameter to the [Products Search](/api-reference-v3/stockx/search) endpoint.
# Changelog v3.0.5 (2025-02-11)
**Migration**
* [Products Search v2](/api-reference-v2/endpoint/products) has been migrated to v3 database. The response structure is left unchanged, however, `blurhash`, `gender` and `weekly_gmv` will always return null.
# Changelog v3.0.4 (2025-02-10)
**New features**
* Added the [Get related products (StockX)](/api-reference-v3/realtime/stockx-related) endpoint to the Realtime API, allowing to gather related products from a product.
# Changelog v3.0.2 (2025-01-31)
**Improvements**
* Improved real-time API performance.
# Changelog v3.0.1 (2025-01-29)
**New features**
* Added the [StockX ASK/BID endpoint](/api-reference-v3/realtime/stockx-prices) to the Realtime API, allowing to gather
`ASK` and `BID` prices for a StockX product.
**Improvements**
* Added caching to the Realtime API, 5 minutes by default.
* Added the `display[sizes]` parameter to the [Search StockX Product](/api-reference-v3/stockx/search) endpoint.
# Changelog v3.0 (2025-01-27)
**New version of KicksDB**
* Release of KicksDB v3.0. Head over to the [API Documentation](/documentation-v3/home) to learn more.
# v3.1.0
Source: https://docs.kicks.dev/changelog/v3.1
Changelog from 2025-02-14 to 2025-08-06
# Changelog v3.1.29 (2025-08-06)
**Fixes**
* "Fear of Gods" products not being matched in Unified API.
* Normalized SKUs for Kicks Crew and Stadium Goods in GTIN API.
* GOAT products not being updated due to API changes.
* StockX Realtime API improvements.
* **Breaking change:** GOAT Realtime search endpoint was fixed, response structure changed.
* Increased refresh rate for Kicks Crew.
# Changelog v3.1.28 (2025-07-25)
**Features**
* Added [Unified API](/api-reference-v3/unified/product) endpoint, combining products from multiple sources by using multiple criteria to identify similar products.
**Fixes**
* Shopify data was not being updated correctly.
# Changelog v3.1.27 (2025-07-21)
**Fixes**
* Fixed `display[prices]` parameter not working correctly on `/api/v3/stockx/products/{id}` endpoint.
**Misc**
* Improved [KicksDB Explorer](https://explorer.kicks.dev):
* Added express prices in the variant price chart.
* Added 3 months and annual statistics cards.
# Changelog v3.1.26 (2025-07-18)
**Features**
* Added `display[statistics]` parameter to the [StockX Product Search](/api-reference-v3/stockx/search) and [StockX Product Detail](/api-reference-v3/stockx/product) endpoints.
**Fixes**
* Product updating and discovery was not working correctly for StockX.
# Changelog v3.1.25 (2025-07-09)
**Features**
* StockX real-time API is now available again! Important notes:
* It's available only in the Standard, previous plans are not supported (expect Enterprise).
* It's now limited to 60 requests per minute instead of 120, this might be raised in the future.
* We are still testing it and we don't guarantee it'll stay available.
**Misc**
* Refreshed documentation for [Real-time Data](/documentation-v3/real-time).
# Changelog v3.1.24 (2025-07-07)
**Features**
* Added [Sales Chart](/api-reference-v3/stockx/chart) endpoint to the StockX API.
# Changelog v3.1.23 (2025-06-27)
**Features**
* Added new search engine with advanced filtering capabilities to [GOAT Search](/api-reference-v3/goat/search) endpoint.
* Added a more detailed `categories` field to StockX API endpoints, with filtering capabilities.
**Deprecations**
* GOAT Search: `slugs` and `sku` parameters are deprecated, use `filters` instead.
**Misc**
* Added possibility to pay by crypto via Coinbase.
# Changelog v3.1.22 (2025-06-22)
**Features**
* Express Standard and Express Expedited prices are now available for StockX products. Enable them with the `display[prices]` parameter in the [StockX Product Search](/api-reference-v3/stockx/search) endpoint and the [StockX Product Detail](/api-reference-v3/stockx/product) endpoint.
* Added `cursor` parameter to [Shopify API endpoints](/api-reference-v3/shopify/search), allowing to paginate through the results and bypass the 50 page limit.
* GOAT variants (with lowest price) are now available via StockX API (see [StockX Product Detail](/api-reference-v3/stockx/product)).
* Added `position` to StockX variants, allowing to have sizes in the correct order.
**Bug fixes**
* StockX search engine was not correctly configured and was returning imprecise results.
**Improvements**
* StockX products with empty `gallery` field will be filled with default `image_url` when provided.
# Changelog v3.1.21 (2025-06-17)
**Improvements**
* Shopify API is now using the new search engine, same as StockX. Advanced `filters` parameter is now supported.
* Kicks Crew and Stadium Goods API endpoints are now deprecated, use [Shopify API](/api-reference-v3/shopify/search) instead.
**Bug fixes**
* Shopify scraper had some issues fetching products, it's now fixed.
# Changelog v3.1.20 (2025-06-12)
**Features**
* Added complex queries support to the [StockX Product Search](/api-reference-v3/stockx/search) endpoint.
**Deprecations**
* Every pre-defined filters of [StockX Product Search](/api-reference-v3/stockx/search) endpoint are deprecated, use `filters` instead.
# Changelog v3.1.19 (2025-06-08)
**Features**
* Added enhanced coverage for CHF market for StockX. Read more about [Markets and currencies](/documentation-v3/markets).
* Added `display[hidden_variants]` parameter to the [StockX Product Search](/api-reference-v3/stockx/search) endpoint.
* Added `display[hidden_variants]` parameter to the [StockX Product Detail](/api-reference-v3/stockx/product) endpoint.
**Improvements**
* StockX contains some duplicate/inactive variants, they are now hidden by default and can be shown with the `display[hidden_variants]` parameter.
# Changelog v3.1.18 (2025-06-06)
**Features**
* Added 8 new stores on our Shopify integration, cumulating to 35 stores.
**Bug fixes**
* Repaired every GOAT realtime endpoints and added them into our status page for better monitoring.
**Improvements**
* V2 and RapidAPI search endpoints was reworked to use new search engine.
* Added `gallery_360` to search results in v3.
**Removals**
* `size` parameter is removed from the [Products Search (v2)](/api-reference-v2/endpoint/products) endpoint.
* `under_price` parameter is removed from the [Products Search (v2)](/api-reference-v2/endpoint/products) endpoint.
# Changelog v3.1.17 (2025-06-03)
**Features**
* Rewritten search engine for StockX products:
* Results are now much more accurate.
* Performance is also greatly improved.
* The `total` count returned is limited to 1000, even if there are more products, this is the only trade-off of this solution, it might change in the future.
**Improvements**
* Improved `display[variants]` performance for StockX products.
**Removals**
* `size` and `max_price` parameters are removed from the [StockX Product Search](/api-reference-v3/stockx/search) endpoint.
# Changelog v3.1.16 (2025-06-02)
**New features**
* Added Shopify integration:
* Added [Shopify](/api-reference-v3/shopify/shops) endpoint to get all shops.
* Added [Shopify](/api-reference-v3/shopify/product) endpoint to get a product.
* Added [Shopify](/api-reference-v3/shopify/search) endpoint to search products.
**Bug fixes**
* StockX:
* `FR` and `DE` markets had only 30% of products being daily-updated.
* Some SKUs were not extracted correctly due to `traits` vs `styleId` difference.
# Changelog v3.1.15 (2025-05-27)
**Performance**
* Greatly improved price retrieval performance for StockX products.
* Sales count (15, 30, 60 days) is now pre-aggregated and cached.
* Sizes retrieval performance is improved.
**Improvements**
* `display[sizes]` parameter is removed and enabled by default for following endpoints:
* [StockX Product Search](/api-reference-v3/stockx/search)
* [StockX Product Detail](/api-reference-v3/stockx/product)
# Changelog v3.1.14 (2025-05-21)
**Features**
* Re-added `total_asks` support.
* Re-added `subtotal` support for StockX via `display[subtotal]` parameter:
* [StockX Product Search](/api-reference-v3/stockx/search)
* [StockX Product Detail](/api-reference-v3/stockx/product)
* Added `FI.vat-registered` market data.
**Removals**
* `display[market_germany]` parameter is removed, use `currency` and `market` query parameters instead.
* `display[price_gbp]` parameter is removed, use `currency` and `market` query parameters instead.
* `display[asks]` parameter is removed.
# Changelog v3.1.13 (2025-05-20)
**Features**
* Added support for France/EUR market.
* Added `currency` and `market` query parameters to:
* [StockX Product Search](/api-reference-v3/stockx/search)
* [StockX Product Detail](/api-reference-v3/stockx/product)
**Deprecation notice**
* `display[market_germany]` parameter is deprecated, use `currency` and `market` query parameters instead.
* `display[price_gbp]` parameter is deprecated, use `currency` and `market` query parameters instead.
* `subtotal` might be removed in the future, please avoid relying on it.
* `previous_*` fields might be removed in the future, please avoid relying on them.
# Changelog v3.1.12 (2025-05-15)
**Features**
* Introduced a new way to update products' prices:
* Working on three markets: US (USD), UK (GBP) and Germany (EUR).
* Updated between 2 and 4 times per day.
* **You can ask for a specific market, we can add it.**
* This is supposed to replace realtime API which is actually down.
* Added `display[market_germany]` parameter to the [StockX Product Search](/api-reference-v3/stockx/search) endpoint.
* Added `display[market_germany]` parameter to the [StockX Product Detail](/api-reference-v3/stockx/product) endpoint.
* Added `subcategory` parameter to the [StockX Product Search](/api-reference-v3/stockx/search) endpoint.
* Inverted `category` and `product_type` parameters to match correctly the response.
**Bug fixes**
* SKU, category and traits are now updated correctly, based on StockX API response.
* Reduced number of products returned in GOAT webhooks, causing too large payloads.
# Changelog v3.1.11 (2025-05-11)
**Features**
* Added `gender` parameter to the [StockX Product Search](/api-reference-v3/stockx/search) endpoint.
# Changelog v3.1.10 (2025-04-26)
**Features**
* Added `display[variants]` parameter to the [GOAT Product Search](/api-reference-v3/goat/search) endpoint.
* Added [product detail route for GOAT](/api-reference-v3/goat/product).
**Improvements**
* Added `country` support for GOAT sales history.
* Added numbers of asks and product type for StockX webhooks.
**Bug fixes**
* Fixed potential issue with GOAT Realtime API.
# Changelog v3.1.9 (2025-04-23)
**Features**
* Added [GOAT monitoring via webhooks for GBP prices](/webhooks-v3/events/goat-price-updated-gbp).
# Changelog v3.1.8 (2025-04-13)
**Improvements**
* Added `gender` to StockX product listing.
**Bug fixes**
* Webhooks for `GBP` price change can prepare up to 1500 products at once, was 50 before.
* Due to pipeline migration, gathering new StockX products was not migrated yet, it's now done.
# Changelog v3.1.7 (2025-04-03)
**New features**
* Added the [Get recent orders (Alias)](/api-reference-v3/realtime/alias-recent-orders) endpoint to the Realtime API, allowing to gather recent orders for a product from Alias.
**Bug fixes**
* Parameter `display[sizes]` alone was returning an error on StockX Product Search.
# Changelog v3.1.6 (2025-04-01)
* SneakersAPI.dev is now renamed to KicksDB, with the domain being updated to kicks.dev.
API endpoint is now `https://api.kicks.dev/v3/`. Old endpoints are still available.
# Changelog v3.1.5 (2025-03-20)
**New features**
* Added `stockx.lowest_ask.updated.usd` event to the Webhook API.
**Improvements**
* Changed the `display[price_gbp]` response structure to include `lowest_ask_gbp` in each variant instead of a sub-object.
* Processing time of webhook greatly improved.
* Processing time of general scraping improved as well.
* Improved product updating process.
**Bug fixes**
* Product rank being not updated.
* Added a new scraping job to ensure we don't miss any product from StockX.
# Changelog v3.1.4 (2025-03-12)
**New features**
* Added the `display[price_gbp]` parameter to the [Search StockX Product](/api-reference-v3/stockx/search) endpoint.
* Added the `display[price_gbp]` parameter to the [Product Detail](/api-reference-v3/stockx/product) endpoint.
**Bug fixes**
* `upcoming` field was only returned when sorting by `release_date` (StockX Product Search).
# Changelog v3.1.3 (2025-02-28)
**New features**
* Added the [GraphQL endpoint](/api-reference-v3/realtime/stockx-graphql) to the Realtime API, allowing to make any query directly on StockX without any rate-limit.
# Changelog v3.1.2 (2025-02-25)
**Improvements**
* Fixed a bug where some products are duplicated in the response.
* Improved real-time API performance.
# Changelog v3.1.1 (2025-02-24)
## Webhook Update
**New features**
* Added webhook features to the API. [Learn more](/webhooks-v3/introduction).
* Added the `stockx.price.updated.usd` event.
* Added the `stockx.price.updated.gbp` event.
**Improvements**
* Improved candidate selection for product updating by prioritizing every ranked product and products with a release date difference of less than 365 days
# Changelog v3.1.0 (2025-02-21)
## Dashboard Update
**New features**
* Users can now access a dashboard to monitor and manage their API usage. [Check out the dashboard](https://app.kicks.dev/dashboard).
**Bug fixes**
* Fixed our pipeline and realtime APIs not being able to fetch data for StockX products.
# v3.2.0
Source: https://docs.kicks.dev/changelog/v3.2
Changelog from 2025-08-18 to 2025-10-18
## KicksDB 3.2.11 – October 18, 2025
* GOAT:
* Repaired missing sales history data, over 3.5M+ data points now!
* StockX:
* Added `primary_title` and `secondary_title` in API response.
## KicksDB 3.2.10 – October 10, 2025
* GOAT Real-time API:
* Massive improvement on Search endpoint, much more details are now returned. **This change may break your actual code!**
* StockX:
* Following markets: FI, JP, ES and CA were not updated correctly, it's now fixed.
## KicksDB 3.2.9 – October 8, 2025
* GOAT:
* Fixed newest/latest products not being searchable.
* GOAT Real-time API:
* Flattened response for search endpoint.
* Fixed 403 errors on for offers and sales.
## KicksDB 3.2.8 – October 5, 2025
* Unified API:
* Upgraded `/gtin` endpoint to support new search engine and more parameters. Better relevance and performance.
## KicksDB 3.2.7 – September 29, 2025
* StockX:
* Added `IT` market.
## KicksDB 3.2.6 – September 23, 2025
* Filtering by `variant_id` is now possible for:
* Real-time API StockX Asks
* Real-time API StockX Sales History
* Pro-tier (from september) can access now Real-time API, one request costs 2x requests.
## KicksDB 3.2.5 – September 18, 2025
* Announcing new webhook feature: Product Monitors
* Previous system: global webhooks are deprecated and will shutdown in few weeks.
## KicksDB 3.2.4 – September 16, 2025
* StockX:
* Added breadcrumbs in product response and filters
* KicksDB:
* Fixed Free tier request quota not being monthly reset
## KicksDB 3.2.3 – September 10, 2025
* GOAT Webhooks:
* Some products were not updated due to old matching system being still used
* SKU and sizes are now returned from StockX matched data.
## KicksDB 3.2.2 – September 5, 2025
* StockX:
* Fixed `minPrice` being zero (= unavailable).
* Products response was not ordered correctly by relevancy.
* Drastically improved response time when using `display[kickscrew]` and/or `display[stadiumgoods]`
* Unified API:
* GTINs not being refreshed correctly.
* Shopify:
* Kicks Crew not being refreshed correctly.
* Improved response latency. Our P95 went from 900ms to 500ms.
* Improved webhook packing, less webhooks are sent, 512kb max per request.
## KicksDB 3.2.1 – August 19, 2025
**Features:**
* Added a new route to get StockX subtotal price (price with shipping) in the real-time API.
## KicksDB 3.2 – August 18, 2025
KicksDB 3.2 introduces following changes:
* Moved servers to better and more powerful infrastructure
* Rewritten all the API using OpenAPI 3 with validators and examples
* Moved API documentation to new website
* Fixed `display[kickscrew]` and `display[stadium_goods]` returning error 500. These parameters are still deprecated, we recommend moving to Unified API
* Improved response time for `/v3/stockx/products/`
* Fixed products having same `rank` value in StockX and GOAT
# Current - v3.3.0+
Source: https://docs.kicks.dev/changelog/v3.3
Changelog starting from 2025-12-08
## API
* **StockX**:
* Fixed duplicated prices in price batch endpoint
* **GOAT**:
* Added price batch endpoint (`/v3/goat/prices`)
## API
* **StockX**:
* Migrated remaining endpoints to the `pckt.sh` data layer:
* Search (`/v3/stockx/products`)
* Get product (`/v3/stockx/products/[id]`)
* Price batch (`/v3/stockx/prices/`)
* Fixed date error on `/v3/stockx/products/[id]/sales/daily`
* Added `express_nextday` pricing type.
* Added sorting by `id` + filter by `id` for a better cursor-based pagination.
* *Breaking:* Removed `PL` and `BE.vat-registered` markets, they're still available in the real-time API. We noticed they were almost never used in the standard API.
## API
* **GOAT:**
* Migrated all GOAT endpoints to the new **Packet (pckt.sh)** data layer:
* Search
* Get Product
* Sales History
* Daily Aggregated Sales History
* **Breaking changes:**
* Sales History and Daily Aggregated Sales History now use **cursor-based pagination**.
* Sales History is now available only for the **US** market.
* `IT` market was removed.
* **StockX:**
* The `/daily` sales endpoint now serves updated data.
## API
* [StockX / Get sales history](https://api.kicks.dev/docs#tag/stockx/GET/v3/stockx/products/\{id}/sales) is working again after few months of interuption. However, please note:
* Only US and DE markets
* Best-effort scraping, updated every 2-3 days only.
* **Breaking change:** `page` and `limit` parameters are not supported anymore. `cursor` must be used now.
* New history that is limited to 3 last months
* Aggregated endpoint `/daily` is not fixed yet.
## API
* Fixed non-2xx responses from incrementing requests usage.
* StockX:
* Fixed `sales_count_[XX]_days` returning outdated data.
* Misc:
* Lot of backend optimizations on real-time requests.
## Shopify Manager
* Added price rounding in pricing rules. Presets possibles: no rounding (original price), `.00`, `.50`, `.90`, `.95`, or `.99`.
## API
* StockX:
* `/v3/stockx/products/[id]` responding in 404 will now scrape the missing product (was already present), but also index it in our search engine directly (new).
## Breaking change
* Search Engine:
* `prices` are not longer filterable in StockX and GOAT endpoints
* `sku_cleaned` filter was removed on Shopify, base `sku` is cleaned when possible by default now.
## API
* SDK:
* Initial release of [KicksDB JavaScript SDK](https://www.npmjs.com/package/@kicksdb/sdk)
* Shopify:
* Fixed outdated data issue.
* Exports:
* Removed CSV Export API.
## Breaking change
* HTTP Webhooks was officially removed. Please use SSE instead.
## API
* StockX:
* Added `PL` market.
* Fixed ranking issues.
* Fixed zero prices not showing in StockX Batch Price endpoint.
* GOAT:
* Fixed critical issue where some out of stock notications were not caught.
* Shopify:
* Added new source: SNS (`sneakersnstuff`).
* Product Clustering / Matching products:
* Added SNS source
* Added official Nike source
## Website
* Added [Shopify integration](/guides/shopify/).
* Added daily requests chart.
## API
* StockX:
* `/api/v3/stockx/product/[id]` returning a 404 will automatically trigger a task to find the missing product, in most of case reloading will give the product.
* Added `DK` market, refreshed once a day.
## Website
* Overages/PAYG can now be previewed on your dashboard
* The dashboard UI was refreshed
## Support
* We're moving away from Discord for ticket-management, please use the chat directly on kicks.dev from now.
* Otherwise, contact to [support@kicks.dev](mailto:support@kicks.dev) still works.
## API
* Migrated following APIs to a new database with lower latency:
* StockX
* GOAT
* Kream
* Novelship
This new database offers better latency for highly updated sources such as
StockX and GOAT. Before, database write latency and cache applied could keep
products unsynced for up to 4 hours.
## Webhooks
* Deprecated webhooks in favor of server-side events (SSE), [read more here](/events/introduction).
## API
* Shopify API:
* Added `sku_cleaned` into filters, allowing more efficient SKU search.
## API
* Added Novelship API, currently in beta:
* [API Reference](https://api.kicks.dev/docs#tag/novelship/GET/v3/novelship/products)
* [Source guide](/guides/sources)
* [Filters](/recipes/filters)
* Unified API:
* Added support for Novelship products in Unified API and GTIN endpoint.
## API
* Added SNKRS API, currently in beta:
* [API Reference](https://api.kicks.dev/docs#tag/snkrs/GET/v3/snkrs/products)
* [Source guide](/guides/sources)
* [Filters](/recipes/filters)
## API
* Added Kream API, currently in beta:
* [API Reference](https://api.kicks.dev/docs#tag/kream/GET/v3/kream/products)
* [Source guide](/guides/sources)
* [Filters](/recipes/filters)
## API
* Markets can now be specified for Unified API requests, the delay between prices being updated was also lowered.
* `metadata` field was added to Shopify API responses, notably for Kicks Crew products.
* Special products were removed from StockX API responses (only `STANDARD` listing type is now supported).
* This avoids special products like `AUCTION` or `RESTOCK` being returned.
* Added new markets to GOAT API:
* Netherlands with `NL` code.
* Italy with `IT` code
## Documentation
* Added maximum latency for each market to [Markets and currencies](/guides/markets) guide.
## API
* CSV exports are now available! Here is the current planning of this new feature:
* From today, you can export the prices of the top 5,000 products by sales volume, in the market of your choice.
* In the coming weeks, we will add custom exports, allowing you to export products based on the criteria you want.
* StockX is currently the only platform supported, GOAT will be added in the coming weeks.
* Exports are available from Starter plan and above.
* CSV exports are available in the dashboard, under the "CSV Exports" section or via the API.
## API
* Added `similarity` parameter to `/unified/products` endpoint, it allows filtering products with a similarity score in addition to the existing cross-matching algorithm. The default threshold is 0.85.
## API
* Migrated `/unified/products` endpoint to new database engine:
* Rewritten cross-matching algorithm, it's now more accurate and faster.
* Added support for searching on SKU and Product IDs, slug is still supported and recommended way.
* Currently, around 340k products posses at least one related product.
* Read [our new recipe](/recipes/unified-api-search) to learn more.
## API
* Migrated `/unified/gtin` endpoint to new database engine.
## Fixes
* Rewritten price tracking logic for webhooks.
## API
* **Breaking change:** GOAT APIs now use `market` instead of `currency` parameter, by default it's `US`. The following markets are now supported:
* `US` -> USD
* `UK` -> GBP
* `IT` -> EUR (new)
## API
* Added following fields to StockX API (including Batch API):
* `beat_us_price` -> Price needed to beat the lowest price in US market.
* `sell_faster` -> Price needed to be the lowest ask to more buyers.
* `earn_more` -> Price needed to be the lowest ask in the selected market.
## API
* Added following markets to StockX API:
* `BE.vat-registered`, for Belgium VAT-registered products.
* Fixed some prices being missing for StockX products.
## API
* Added batching support for StockX prices endpoint:
* [Recipe](/recipes/stockx-batch-prices)
* [API Reference](https://api.kicks.dev/docs#tag/stockx/post/v3stockxprices)
## API
* Migrated database to another engine, improving performance and reliability. Some endpoints are not yet migrated.
* Fixed an issue with GOAT sales history columns being wrongly named.
* Fixed `display[...]` parameters with nested effects being required to be set to `true`.
* Fixed express shipping prices not being returned correctly for StockX products.
* Fixed price merging logic causing some prices to be outdated.
## Documentation
* Rewritten documentation website with recipes and guides.
## Removed endpoints
This new version of KicksDB removed following deprecated endpoints:
* Removed API v2.
* Removed Kicks Crew, use Shopify API instead.
* Removed Stadium Goods, use Shopify API instead.
* Removed StockX Chart API, use daily sales history instead.
# Introduction
Source: https://docs.kicks.dev/events/introduction
Receive notifications from KicksDB using Server-Side Events
Before v3.3.14, KicksDB delivered notifications using HTTP webhooks.
Webhooks are now deprecated and being removed.
We've switched to **Server-Side Events (SSE)**, a single long-lived HTTP connection that continuously streams events to your application.
### Why we moved
**Webhooks**
* Multiple outbound HTTP requests
* Required batching events to reduce overhead
* Custom retry & delivery logic
* Harder to guarantee consistency at scale
**SSE**
* One persistent connection
* Events streamed individually in real time
* Built-in reconnection support
* Lower infrastructure overhead
* Cleaner, more scalable architecture
Instead of pushing thousands of POST requests, KicksDB now streams events over one open connection.
***
## Availability
SSE access is **reserved to Pro and Enterprise plans only**.
If you need real-time event streaming, contact our team to upgrade your plan.
# Usage
Source: https://docs.kicks.dev/events/usage
How to connect and consume KicksDB SSE
## Endpoint
* **URL:** `GET https://sse.kicks.dev/v1/stream`
* **Protocol:** `text/event-stream`
* **Authentication:** `Authorization: Bearer YOUR_API_KEY`
* **Plan requirement:** Pro membership
The connection remains open and continuously streams events as they occur.
# Selecting Topics
SSE currently supports **price updates** for:
* StockX (all markets)
* GOAT (all markets)
You must specify which markets to listen to using the `Topics` header.
### Header format
```
Topics: price:stockx:us, price:stockx:uk, price:goat:us, price:goat:nl
```
### Rules
* Format: `[event_type]:[source]:[country_code]`
* Lowercase only
* Comma-separated
### Example request
```http theme={null}
GET https://sse.kicks.dev/v1/stream
Authorization: Bearer YOUR_API_KEY
Topics: price:goat:uk, price:goat:us, price:stockx:us
```
KicksDB is primarily a product catalog, not a tick-level trading feed.
Some markets may not emit events for extended periods depending on refresh cycles.
Refer to [sources and markets](/guides/sources) for refresh expectations.
# Event Format
Each event follows the standard SSE format:
```
id: 152
event: price:goat:uk
data: { ...json payload... }
```
### Fields
* `id` — unique incremental event ID
* `event` — topic name (`source:market`)
* `data` — JSON payload
### Example Payload
```json theme={null}
{
"source": "goat",
"product_id": "583450",
"variant_id": "8",
"size": "8",
"price": 150,
"currency": "GBP",
"market": "UK",
"sku": "FW3725",
"timestamp": "2026-02-24T23:46:11.910541096Z"
}
```
# Node.js Example
Node 18+ has native `fetch` support.
This example uses the `eventsource` package for automatic reconnection handling.
### Install
```bash theme={null}
npm install eventsource
```
### Example Listener
```js theme={null}
import { EventSource } from "eventsource";
const topics = ["price:stockx:us", "price:goat:uk"];
const es = new EventSource("https://sse.kicks.dev/v1/stream", {
fetch: (input, init) =>
fetch(input, {
...init,
headers: {
...(init.headers || {}),
Authorization: `Bearer [YOUR_API_KEY]`,
Topics: topics.join(","),
},
})
});
es.onopen = () => {
console.log("Connected to KicksDB SSE");
};
es.addEventListener("price:goat:uk", (event) => {
const payload = JSON.parse(event.data);
console.log("GOAT UK update:");
console.log(payload);
});
es.onerror = (err) => {
console.error("SSE connection error:", err);
};
```
# Reconnection & Resume (Recommended)
SSE supports automatic reconnection.
For production systems:
* Persist the last processed `id`
* Reconnect with `Last-Event-ID` header
* Use exponential backoff if connection fails repeatedly
* Run listener in a dedicated worker process
Only the 5,000 last events are retryable.
# Testing with CLI
You can test streaming manually:
```bash theme={null}
http --stream https://sse.kicks.dev/v1/stream \
"Authorization: Bearer YOUR_API_KEY" \
"Topics: price:goat:uk"
```
If successful, you'll receive a continuous stream:
```
id: 152
event: goat:uk
data: { ... }
id: 153
event: goat:uk
data: { ... }
```
# APIs
Source: https://docs.kicks.dev/guides/apis
Overview of our APIs
```mermaid theme={null}
flowchart BR
A(**Standard API**) --> B(KicksDB Database) --Refreshed daily--> C(Platforms)
E(**Unified API**) --Computed from our cross-matching algorithm--> B
F(**Real-Time API**) --Instantly requested--> C
click A "#standard-api"
click E "#unified-api"
click F "#real-time-api"
```
## Standard API
The Standard API includes access to the following platforms:
* **StockX**
* **GOAT**
* **Shopify** (Kicks Crew, Stadium Goods, and 30+ more)
It's our most used API, it returns data from the platforms in an easy to use format. It also includes sales history for StockX and GOAT.
## Unified API
The Unified API uses platforms specified above and cross-matches the data to provide a unified view of the product. It's a good choice if you want to compare data or display availability and pricing for multiple platforms.
Our algorithm is designed to match products based on their SKU, MPN, GTIN, and other identifiers. However, it might, in some rare cases, not be able to match the product or create false-positives.
## Real-Time API
The Real-Time API scrapes the platforms in real-time to provide the most up-to-date data. It's a good choice when timing is critical, however, it's limited to paying users and rate-limited to 1 request per second. We do not recommend using this API for bulk requests, but only for single requests.
StockX and GOAT are the only platforms that support real-time API.
# Authentication
Source: https://docs.kicks.dev/guides/authentication
How to authenticate with KicksDB
![API keys can be found in your account dashboard]()
You can find [your API keys](https://kicks.dev/api-keys) in your account dashboard. It should look like this:
```
KICKS-1234-ABCD-1234-123456ABCDEF
```
Once you have your API key, you can use it to authenticate your requests to our APIs by including it in the `Authorization` header, using the `Bearer` scheme:
```http theme={null}
Authorization: Bearer KICKS-1234-ABCD-1234-123456ABCDEF
```
## Response headers
When you make a request to our APIs, we will return some response headers with useful information. Here are the ones you should pay attention to:
| Header | Description |
| ----------------- | ----------------------------------------------------------------- |
| `X-Quota-Current` | The number of requests you have made so far in the current month. |
| `X-Key-Type` | The type of API key you are using. |
# Introduction
Source: https://docs.kicks.dev/guides/index
Get started with KicksDB
## What is KicksDB?
KicksDB is a platform that collects data from various sneaker and apparel platforms. We provide multiple REST APIs to access the data, according to your needs.
Here are some type of data we provide:
* **Product metadata**: name, brand, release date, price (MSRP), color, size, etc...
* **Product images**: gathered from multiple sources, including official product images.
* **Product availability**: whether the product is in stock, and where to buy it.
* **Product history**: price and sales history.
* **Product barcodes**: EAN, UPC and GTIN codes.
## What APIs do we offer?
Our most popular API, providing metadata and prices per platform.
An API that provides metadata in an unified format by cross-matching data
from multiple platforms.
A real-time API that provides data about the product's availability and
pricing.
All APIs have pros and cons, and you should choose the one that best fits your needs. Some examples:
* **Standard API**: It's our most popular API, if you need to get product metadata or prices from a specific platform (e.g. StockX), it's the best choice. The data is cached and refreshed every 24 hours at maximum.
* **Unified API**: If you want to access and compare data from multiple platforms without having to deal with different endpoints, parameters and response formats, the Unified API is the best choice. However, it might not contain all products, depending on our cross-matching algorithm.
* **Real-Time API**: If you need to get real-time data about the product's availability and pricing, the Real-Time API is the best choice. The data represents the current state of the product on the market. This API is, however, limited to paying users and rate-limited.
## How to get started?
To get started, you can [sign up](https://kicks.dev/register) for a free account on our website. Once you have an account, you'll receive an API key that you can use to access our APIs.
The free-tier allows you to make 1,000 requests per month on Standard API. If you need more requests and other features, you can upgrade to a paid plan. All plans includes a 3-day free trial, cancellable at any time.
Sign up for a free KicksDB account on our website, it takes less than 1
minute.
# Troubleshooting
Source: https://docs.kicks.dev/guides/shopify/faq
Common questions and issues on Shopify integration.
## My Shopify store won't connect to KicksDB
Please double-check the following:
* The shop name should be without the `http(s)://` prefix and without the `.myshopify.com` suffix.
* The Client ID and Secret should match what is shown in the Shopify Developer Dashboard.
* The scopes should be correct — please refer to our guide.
## My products don't get synchronized
This might be caused by:
* A duplicated handle in your Shopify store.
* A field that is incorrectly formatted or empty.
* An uncaught or unknown error — please contact us :)
## What refresh rate should I use?
We offer four different refresh rates, ranging from 24 hours to 15 minutes.
Pricing varies based on the selected refresh rate.
* **24 hours** → Best for products with low volatility and high available quantity.
* **4 hours or 1 hour** → A middle range for medium volatility, and often the safest choice.
* **15 minutes** → Best for products with very high volatility and large price variations.
By default, we recommend 4 hours with a strict pricing rule to avoid errors.
## I don't see the product on my storefront.
This is a safety measure — we never touch your sales channels or publications.
KicksDB only uploads and updates products in your Shopify administration panel. You can then select products and enable the "Online Store" sales channel to make them available to your customers.
## I deleted a product or a variant and it's still on my shop.
* Deleting a product or an individual variant from KicksDB only stops the synchronization.
* Deleting a product or an individual variant from Shopify will update KicksDB to stop further synchronization.
This is a safety procedure, but it also allows you to create products or variants through KicksDB using our automated product creation and later manage them manually, detached from KicksDB automations.
## What scopes are required?
We require the following permissions on your Shopify store:
* `read_inventory` / `write_inventory` → Allows us to update product quantity.
* `read_products` / `write_products` → Allows us to create and update products and variants.
* `read_locations` → Inventories (product quantities) are scoped to a location; without this, we cannot update quantities.
# Get started
Source: https://docs.kicks.dev/guides/shopify/index
Automatically manage your Shopify products and pricing with KicksDB
KicksDB integrates directly with your Shopify store to automate product management, keeping your storefront in sync with live market data from StockX and GOAT.
## What's included
Automatically create and publish products on your Shopify storefront using
data sourced from StockX or GOAT.
Keep prices up to date with a 15-minute refresh cycle, pulling live data
from StockX or GOAT.
Define dynamic margin rules using KicksDB's node editor to control your
pricing strategy at scale.
## Prerequisites
Before connecting your store, make sure you have:
* A KicksDB account with access to the [dashboard](https://kicks.dev/dashboard)
* Admin access to your [Shopify store](https://shopify.com/admin)
* Access to the [Shopify Developer Dashboard](https://dev.shopify.com/dashboard/) to create a custom app
## Connect your Shopify store
### Step 1 — Create a custom app in Shopify
1. Go to your [Shopify Developer Dashboard](https://dev.shopify.com/dashboard/) and click **Create App**.
2. Enter any app name (e.g. `kicksdb`) and confirm.
3. In the **App URL** field, enter:
```
https://via.kicks.dev/api/shopify/initialize
```
4. Under **Scopes**, add the following permissions:
```
write_inventory,read_inventory,read_locations,read_products,write_products
```
![Shopify Dev Dashboard configuration]()
5. Click **Release** to finalize the app.
6. Navigate to **Settings** — your **Client ID** and **Secret** will be listed there.
![Shopify API credentials]()
### Step 2 — Connect the store in KicksDB
1. Open your [KicksDB dashboard](https://kicks.dev/dashboard) and go to the **Stores** page.
2. Click **Connect store** and fill in the form.
3. For the **Shop name**, go to your [Shopify Admin](https://shopify.com/admin) and copy the name from the URL:
![Finding your Shopify shop name]()
4. Paste the **Client ID** and **Secret** from the previous step.
5. Click **Save**, then click **Install** from KicksDB.
You'll be redirected back to KicksDB once the installation is complete.
![KicksDB store connected]()
Always install the app from KicksDB — not from the Shopify Developer
Dashboard. This ensures your credentials and configuration are saved correctly
before the OAuth flow begins.
# Pricing rules
Source: https://docs.kicks.dev/guides/shopify/markup-editor
Plan your margins using our markup editor
![Node Editor]()
The markup editor lets you build pricing rules visually by connecting nodes. Each rule starts from a trigger, routes through optional conditions, and ends with an action that applies a markup to the base price fetched from StockX or GOAT.
## Node types
### Trigger
The entry point of every markup rule. Each rule has exactly one trigger node, and it cannot be deleted.
### Condition
Filters that control when a markup applies. Conditions can be stacked — all must be met for the flow to continue. You can filter on:
| Field | Description |
| :------- | :----------------------------------------------------------------------------------- |
| Source | The data source: StockX or GOAT |
| Price | The base price fetched from your source |
| Quantity | The available quantity. GOAT does not provide quantity data — it always reads as `1` |
### Action
Applies a markup on top of the base price. Multiple actions can be stacked — for example, combining a percentage margin with a fixed amount to cover shipping.
## Applying a markup rule
Markup rules can be assigned at two levels:
**Store level** — Set a default rule in your store settings. This applies automatically to any new products created on that store. Existing products are not affected.
**Product level** — Override the rule for a specific product by editing it directly. This takes precedence over the store-level default.
If you update a store's default rule, existing products will keep their
current rule. To update them, reassign the rule on each product individually.
# Pricing
Source: https://docs.kicks.dev/guides/shopify/pricing
Shopify integration pricing
Shopify integration is available on **Starter** and **Pro** plans. Pricing is based on three factors: the number of products you sync, your chosen refresh rate, and the number of stores connected.
## Product pricing
Pricing scales with how frequently your products are updated:
| Refresh rate | Cost per product/month |
| :--------------- | ---------------------: |
| Every 24 hours | €0.05 |
| Every 4 hours | €0.10 |
| Every 1 hour | €0.20 |
| Every 15 minutes | €0.50 |
### Included products by plan
Each plan includes a product allowance that varies depending on your refresh rate:
| Plan | Every 24 hours | Every 15 minutes |
| :------ | :------------- | :--------------- |
| Starter | 10 products | 1 product |
| Pro | 150 products | 15 products |
Allowances for intermediate refresh rates (every 4 hours and every 1 hour)
fall proportionally between the values above.
## Store pricing
| Plan | Included stores | Additional stores |
| :------ | :-------------- | :---------------- |
| Starter | 1 | €10/store/month |
| Pro | 3 | €10/store/month |
Additional stores beyond your plan's limit are billed at **€10/store/month**.
## Pricing example
Say you're on the **Pro plan** and you run **2 stores** with a total of **200 products** synced at the **every 15 minutes** refresh rate.
**Products**
Your Pro plan includes 15 products at the 15-minute refresh rate. The remaining 185 products are billed at €0.50/product/month:
| | Products | Rate | Cost |
| :------------------------ | -------: | ----: | ---------: |
| 120 products w/ 4hrs rate | 120 | €0.20 | €24.00 |
| 45 products w/ 15mn rate | 30 | €0.50 | €15.00 |
| Included in Pro tier | | | -€7.50 |
| **Total** | **165** | | **€39.00** |
**Stores**
Your Pro plan includes 3 stores, so both stores are covered:
| | Stores | Rate | Cost |
| :------------- | -----: | ----: | --------: |
| Included (Pro) | 2 | €0.00 | €0.00 |
| **Total** | **2** | | **€0.00** |
**Monthly total: €39.00**
The Pro plan subscription cost is not included above — the example only covers
Shopify integration charges.
# Sources and markets
Source: https://docs.kicks.dev/guides/sources
Supported sources and markets
## StockX
| Market | Currency | Maximum latency |
| ----------------- | -------- | --------------- |
| US | USD | 4 hours |
| UK | GBP | 3 hours |
| FR | EUR | 24 hours |
| DE | EUR | 24 hours |
| IT | EUR | 24 hours |
| CH | CHF | 24 hours |
| DK | EUR | 24 hours |
| NL | EUR | 24 hours |
| PL | EUR | 24 hours |
| FI.vat-registered | EUR | 24 hours |
| NL.vat-registered | EUR | 24 hours |
We only fetch the main currency for each market, other currencies are not
supported. - **Supported:** EUR on FR. - **Not supported:** USD on FR.
**Addressing data mismatch**
StockX website allows changing the market and currency in the footer of their website, however, it sometimes does not work as expected, it might still apply your IP location or account's saved address as the market.
We are not responsible for this bug, it might cause data mismatch between our API and what you see on their website.
## GOAT
| Market | Currency | Maximum latency |
| ------ | -------- | --------------- |
| US | USD | 24 hours |
| UK | GBP | 4 hours |
| NL | EUR | 24 hours |
## Flight Club
| Market | Currency | Maximum latency |
| ------ | -------- | --------------- |
| US | USD | 24 hours |
## Shopify
| Shop | Currency | Maximum latency |
| -------------------- | -------- | --------------- |
| kickscrew | USD | 24 hours |
| sneakersnstuff | EUR | 3 days |
| stadiumgoods | USD | 3 days |
| zeropolis-skateshop | EUR | 3 days |
| davrilsupply | EUR | 3 days |
| scuffers | EUR | 3 days |
| divinbydivin | EUR | 3 days |
| derschutze | EUR | 3 days |
| supraw | EUR | 3 days |
| crisplondon | GBP | 3 days |
| arrowbeast | EUR | 3 days |
| starcow-paris | EUR | 3 days |
| buzzz-skateshop | EUR | 3 days |
| wallstreet-skateshop | EUR | 3 days |
| circle-shop-avignon | EUR | 3 days |
| friscoshop | EUR | 3 days |
| streetart | EUR | 3 days |
| 242shop-ch | CHF | 3 days |
| stil-laden | EUR | 3 days |
| ben-g-skateshop | EUR | 3 days |
| blowout | EUR | 3 days |
| bonkers | EUR | 3 days |
| noteshop | GBP | 3 days |
| boredofsouthsea | GBP | 3 days |
| welcome-skate-store | GBP | 3 days |
| decimalstore | EUR | 3 days |
| focus-shop | GBP | 3 days |
| stay-on | EUR | 3 days |
| legacy-skate-store | GBP | 3 days |
| route-one | GBP | 3 days |
| slam-city-skates | GBP | 3 days |
| milk-store | EUR | 3 days |
| cybercafeskate | EUR | 3 days |
| slamjam | EUR | 3 days |
| flatspot | GBP | 3 days |
| solar-mtp | EUR | 3 days |
| lelabostore | EUR | 3 days |
| edgar-bdx | EUR | 3 days |
| specimn | EUR | 3 days |
| vitamine-club | EUR | 3 days |
We don't recommend using Shopify for pricing data as they're not always up to
date. Most shops are updated: Monday, Wednesday and Friday.
## Kream
Kream is a Korean platform with KRW currency support only. We're currently in beta and refreshing the data
at least once weekly. Our API includes `currency` parameter to convert the prices to your preferred currency, currently USD, EUR and GBP.
Exchange rates are refreshed twice daily.
## SNKRS
| Market | Maximum latency |
| ------ | --------------- |
| FR | 24 hours |
| US | 24 hours |
| GB | 24 hours |
| NL | 24 hours |
| DE | 24 hours |
| KR | 24 hours |
| IT | 24 hours |
| ES | 24 hours |
## Novelship
| Market | Maximum latency |
| ------ | --------------- |
| UK | 24 hours |
## Nike
| Locale | Maximum latency |
| ------ | --------------- |
| IT | 24 hours |
| US | 24 hours |
| KR | 24 hours |
| GB | 24 hours |
| NL | 24 hours |
| FR | 24 hours |
# Status codes
Source: https://docs.kicks.dev/guides/status-codes
HTTP status codes used by KicksDB
| Code | Description |
| -------- | ----------------------------------------- |
| 200 | The request was successful. |
| 400, 422 | The request was malformed or invalid. |
| 401 | The API key is invalid or expired. |
| 404 | The requested resource was not found. |
| 429 | The request was rate limited. |
| 500 | The server encountered an internal error. |
## Need help?
Join our Discord server to get help from our community and team.
Don't have a Discord account? Contact us at [support@kicks.dev](mailto:support@kicks.dev) to get help.
# Troubleshooting
Source: https://docs.kicks.dev/guides/troubleshooting
Troubleshooting guide for KicksDB
If you experience any issues with our APIs that are not covered by this page, please join our Discord server and ask for help or open a ticket in the `#tickets` channel.
## I'm getting a 401 error
Possible reasons:
* Your API key is invalid.
* You used all your monthly quota.
* Your trial period or subscription has expired and couldn't be renewed.
## The prices does not match the product page
Possible reasons:
* You're using the wrong market or currency.
* KicksDB has a latency of a few hours, the prices might not be updated yet.
* **StockX only**: There is a bug in StockX website, the "region selector" is not working as expected and might still apply your IP location or account's saved address as the market.
## I cannot find a product
Possible reasons:
* The product is new and wasn't indexed yet by KicksDB.
* **Unified API only**: The product couldn't be matched to any product in other platforms.
Contact us if the bug persists after 24 hours.
# Filtering products by criteria
Source: https://docs.kicks.dev/recipes/filters
How to use filters to get products from KicksDB
KicksDB relies on Meilisearch to search and filter products, our following endpoints uses Meilisearch under the hood:
* StockX
* GOAT
* Shopify
* Kream
These endpoints often have `query` parameter to search for products and `filters` parameter to filter products based on certain criteria. This recipe will show you how to use `filters` parameter.
## Filtering products
You should consult the structure of the indexes below to understand the available filters.
For example, if you want to filter products by brand, you can use the `brand` filter, like this:
```js theme={null}
brand = "Nike";
```
Due to special characters, you might have to [encode the filters](https://www.urlencoder.org/) to avoid errors, it should give a result like this:
```http theme={null}
GET https://api.kicks.dev/v3/stockx/products?filters=brand%3D%22Nike%22
```
It's possible to combine multiple filters, like this:
```js theme={null}
brand = "Nike" AND product_type = "sneakers";
```
Finally, some filters use nested objects, like this:
```js theme={null}
prices["USD_US"]["9.5"] < 100;
```
Values in quotes are not case sensitive.
You can consult the Meilisearch documentation for more information about the
filters.
## Indexes
Indexes are refreshed every 12 hours, you can consult the structure of the indexes below.
### StockX
```json theme={null}
{
"slug": "string",
"brand": "string",
"gender": "string",
"product_type": "string",
"category": "string",
"secondary_category": "string",
"categories": ["string"],
"sku": "string",
"rank": "number",
"release_date": "string",
"colorway": "string",
"barcodes": ["string"],
"breadcrumbs": ["string"],
"updated_at": "date-time",
"created_at": "date-time"
}
```
### GOAT
```json theme={null}
{
"brand": "string",
"slug": "string",
"sku": "string",
"colorway": "string",
"release_date": "string", // Format: YYYYMMDD or YYYY
"rank": "number",
"product_type": "string",
"category": "string",
"model": "string",
"season": "string"
}
```
### Shopify
```json theme={null}
{
"id": "string",
"product_id": "number",
"title": "string", // searchable
"slug": "string", // searchable, filterable
"brand": "string", // searchable, filterable
"product_type": "string", // searchable, filterable
"sku": "string", // searchable, filterable
"tags": ["string"],
"shop_name": "string", // filterable
"updated_at": "string", // sortable
"published_at": "string", // sortable
"prices": {
// filterable
"string": "number" // size: price
},
"barcodes": ["string"], // filterable
"cursor": "number" // filterable, sortable
}
```
### Kream
```json theme={null}
{
"id": "number", // sortable
"name": "string", // searchable
"brand": "string", // searchable, filterable
"category": "string", // searchable, filterable
"colorway": "string", // searchable, filterable
"gender": "string", // filterable
"sku": "string", // searchable, filterable
"release_date": "string" // filterable, sortable
}
```
### SNKRS
```json theme={null}
{
"id": "string",
"country_code": "string", // filterable
"title": "string", // searchable
"subtitle": "string", // searchable
"slug": "string", // searchable, filterable
"skus": ["string"], // searchable, filterable
"barcodes": ["string"], // searchable, filterable
"product_type": "string", // filterable
"status": "string", // filterable
"exclusive": "boolean", // filterable
"start_date": "string" // filterable
}
```
### Novelship
```json theme={null}
{
"id": "string",
"name": "string", // searchable
"brand": "string", // searchable, filterable
"slug": "string", // searchable, filterable
"sku": "string", // searchable, filterable
"colorway": "string", // filterable
"release_date": "string", // filterable
"retail_price": "number", // filterable
"product_type": "string", // filterable
"model": "string", // searchable, filterable
"season": "string" // filterable
}
```
# Get products from GOAT
Source: https://docs.kicks.dev/recipes/goat-get-product
How to get a product from GOAT using KicksDB
There are two ways to get a product from GOAT using KicksDB, depending on the information you have:
You have the SKU or name of the product
You have the URL or ID of the product
You can use the `query` parameter to search for a product by SKU, name, brand, etc...
```http theme={null}
GET https://api.kicks.dev/v3/goat/products?query=[SKU_or_Name]
```
The response will be a list of products that matches the query, ordered by relevance and product popularity, like this:
```json theme={null}
{
"$schema": "https://api.kicks.dev/schemas/RespListGoatProductV2Body.json",
"data": [
{
"id": 92101,
"sku": "854866 019",
"slug": "sb-dunk-low-pro-854866-019",
"name": "Nike Zoom Dunk Low Pro SB 'Black Gum'",
"brand": "Nike",
"model": "Dunk SB",
"description": "Released in December 2016, the Nike SB Dunk Low Pro ‘Black Gum’ features a tonal black finish on a combination leather and suede build. Accented with a crisp white leather Swoosh, a matching white midsole gives way to a grippy gum rubber outsole, completing the classic aesthetic on the low-top.",
"colorway": "Black/White-Gum Light Brown",
"season": " 2016",
"category": "shoes",
"product_type": "sneakers",
"image_url": "https://image.goat.com/1000/attachments/product_template_pictures/images/043/226/760/original/92101_00.png.png",
"images": null,
"release_date": "2016-12-13T23:59:59.999Z",
"release_date_year": "2016",
"retail_prices": null,
"link": "https://goat.com/sneakers/sb-dunk-low-pro-854866-019",
"sizes": [
{
"presentation": "3",
"value": 3
},
{
"presentation": "3.5",
"value": 3.5
}
// ... more sizes ...
],
"rank": 45459,
"weekly_orders": 0,
"updated_at": "2025-12-02T04:48:15Z",
"variants": null
}
// ... more products ...
]
}
```
You can use the `id` or `slug` parameter to get a product by its ID or slug.
```http theme={null}
GET https://api.kicks.dev/v3/goat/products/[ID_or_SLUG]
```
The response will be the product data, like this:
```json theme={null}
{
"$schema": "https://api.kicks.dev/schemas/RespGoatProductV2Body.json",
"data": {
"id": 1381901,
"sku": "CT8012 104",
"slug": "air-jordan-11-retro-columbia-2024-ct8012-104",
"name": "Air Jordan 11 Retro 'Legend Blue / Columbia' 2024",
"brand": "Air Jordan",
"model": "Air Jordan 11",
"description": "The 2024 edition of the Air Jordan 11 Retro 'Legend Blue / Columbia' brings back an OG colorway of the championship model. Laces feed through webbing eyelets to secure the white leather upper, bolstered with a tonal patent leather mudguard and marked with a blue embroidered Jumpman on the lateral collar. Contrasting black accents land on the interior lining and back tab, featuring signature '23' branding. A white Phylon midsole packs a full-length Air-sole unit for lightweight cushioning. Underfoot, a blue-tinged translucent rubber outsole reveals a carbon fiber shank plate for midfoot stability.",
"colorway": "White/Legend Blue/Black",
"season": " 2024",
"category": "shoes",
"product_type": "sneakers",
"image_url": "https://image.goat.com/1000/attachments/product_template_pictures/images/104/574/787/original/1381901_00.png.png",
"images": [
"https://image.goat.com/attachments/product_template_additional_pictures/images/104/574/790/medium/1381901_01.jpg.jpeg",
"https://image.goat.com/attachments/product_template_additional_pictures/images/104/574/789/medium/1381901_02.jpg.jpeg"
// ... more images ...
],
"release_date": "2024-12-14T23:59:59.999Z",
"release_date_year": "2024",
"retail_prices": null,
"link": "https://goat.com/sneakers/air-jordan-11-retro-columbia-2024-ct8012-104",
"sizes": [
{
"presentation": "3.5",
"value": 3.5
},
{
"presentation": "4",
"value": 4
}
// ... more sizes ...
],
"rank": 16,
"weekly_orders": 632,
"updated_at": "2025-12-04T06:25:01Z",
"variants": [
{
"product_id": 1381901,
"size": "10",
"lowest_ask": 202,
"currency": "USD",
"available": true,
"updated_at": "2025-12-05T06:48:41Z"
},
{
"product_id": 1381901,
"size": "10.5",
"lowest_ask": 230,
"currency": "USD",
"available": true,
"updated_at": "2025-12-06T07:15:12Z"
}
// ... more variants ...
]
},
"meta": null
}
```
# Get sales history from GOAT
Source: https://docs.kicks.dev/recipes/goat-get-sales
How to get the sales history of a product from GOAT using KicksDB
In order to get the sales history of a product, you need to know the ID of the product. Follow the [Get a product from GOAT recipe](/recipes/goat-get-product) to get the ID of the product.
Get the sales history of the product
Get the daily aggregated sales history of the product
The following endpoint returns the sales history of the product, including the sale price, date and location.
```http theme={null}
GET https://api.kicks.dev/v3/goat/products/[id]/sales
```
Response example:
```json theme={null}
{
"$schema": "https://api.kicks.dev/schemas/RespListGoatProductSaleBody.json",
"data": [
{
"product_id": 121,
"type": "PURCHASE_TYPE_SALE",
"size_us": "12",
"currency": "USD",
"amount": 200,
"location": "Athens, US",
"purchased_at": "2025-04-20T17:31:00Z"
}
],
"meta": {
"page": 1,
"per_page": 20
}
}
```
The available `type` values are:
* `PURCHASE_TYPE_SALE`: Most common type, it means the product was sold at the "Buy Now" price.
* `PURCHASE_TYPE_OFFER_CLOSED`: It means the product was negotiated and sold at a different price than the "Buy Now" price.
You can use the `/daily` endpoint to get the daily aggregated sales history of the product, like this:
```http theme={null}
GET https://api.kicks.dev/v3/goat/products/[ID_or_SLUG]/sales/daily
```
Response example:
```json theme={null}
{
"$schema": "https://api.kicks.dev/schemas/RespListGoatProductSaleAggBody.json",
"data": [
{
"product_id": 1381901,
"avg_amount": 177.5,
"orders": 28,
"date": "2025-12-08T00:00:00Z"
},
{
"product_id": 1381901,
"avg_amount": 182.95454545454547,
"orders": 88,
"date": "2025-12-07T00:00:00Z"
}
// ... more daily sales ...
]
}
```
# Get prices in batch from StockX
Source: https://docs.kicks.dev/recipes/stockx-batch-prices
How to get the prices of multiple products from StockX using KicksDB
Beta Feature
This recipe shows how to get the prices of multiple products from StockX using KicksDB. It requires a list of product IDs or SKUs.
The request body should include a list of product IDs or SKUs, **when both are provided, only the SKUs will be considered**. Up to 50 products can be requested at once.
Request example:
```http theme={null}
POST https://api.kicks.dev/v3/stockx/prices
Content-Type: application/json
Authorization: Bearer YOUR_API_KEY
{
"market": "US", // US, UK, FR, DE, CH, etc...
// Either product IDs or SKUs:
"product_ids": ["4a4f645a-5b17-498e-9bbc-187a146f6be7"],
"skus": ["1183C468-700"]
}
```
Response example:
```json theme={null}
{
"$schema": "https://api.kicks.dev/schemas/RespListGetPricesOutputBody.json",
"data": [
{
"product_id": "d073dbea-bc16-47b9-8006-851e6bd9faa7",
"sku": "1183C468-700",
"variants": [
{
"id": "3ffd8609-b241-4dbe-918a-339235bd8ad0",
"size": "5",
"size_type": "us m",
"price": 197,
"asks": 4,
"type": "standard"
},
{
"id": "544073bb-36a5-438c-bd94-fced87ce63d7",
"size": "11",
"size_type": "us m",
"price": 196,
"asks": 5,
"type": "standard"
}
// ... more prices ...
]
}
]
}
```
## Remarks
* **Variants with no prices or no variants are omitted from the response.**
* Three types of prices are supported:
* `standard` -> Standard delivery
* `express_standard` -> Express Standard delivery
* `express_expedited` -> Express delivery with 3-day guarantee expedited option
* The list of variants is not ordered.
* The currency is always the main currency of the market (e.g. UK -> GBP).
* The SKUs should be written as they are written on StockX's product page.
# Get products from StockX
Source: https://docs.kicks.dev/recipes/stockx-get-product
How to get a product from StockX using KicksDB
There are two ways to get a product from StockX using KicksDB, depending on the information you have:
You have the SKU or name of the product
You have the URL or ID of the product
You can use the `query` parameter to search for a product by SKU, name, brand,
etc...
```http theme={null}
GET https://api.kicks.dev/v3/stockx/products?query=[SKU_or_Name]
```
The response will be a list of products that matches the query, ordered by relevance and product popularity, like this:
```json theme={null}
{
"$schema": "https://api.kicks.dev/schemas/RespListStockXProductBody.json",
"data": [
{
"id": "1f27cf59-74c3-4ace-a94b-717b0c84465e",
"title": "Jordan 1 Retro High OG Rare Air",
"brand": "Jordan",
"model": "Jordan 1 Retro High OG",
"gender": "men",
"description": "The Jordan 1 Retro High OG Rare Air pays homage to the original 1985 design with a contemporary twist, blending classic elements with modern updates...",
"image": "https://images.stockx.com/images/Air-Jordan-1-Retro-High-OG-Rare-Air-Product.jpg?fit=fill&bg=FFFFFF&w=700&h=500&fm=webp&auto=compress&q=90&dpr=2&trim=color&updated_at=1741385112",
"sku": "DZ5485-100",
"slug": "air-jordan-1-retro-high-og-rare-air",
"product_type": "sneakers",
"category": "Air Jordan",
"secondary_category": "One",
"categories": ["sneakers"],
"breadcrumbs": [
{
"value": "Sneakers",
"alias": "sneakers",
"level": 1
},
{
"value": "Lifestyle",
"alias": "lifestyle",
"level": 2
}
],
"gallery": [
"https://images.stockx.com/images/Air-Jordan-1-Retro-High-OG-Rare-Air-Product.jpg?fit=fill&bg=FFFFFF&w=700&h=500&fm=webp&auto=compress&q=90&dpr=2&trim=color&updated_at=1741385112"
],
"gallery_360": [
"https://images.stockx.com/360/Air-Jordan-1-Retro-High-OG-Rare-Air/Images/Air-Jordan-1-Retro-High-OG-Rare-Air/Lv2/img01.jpg?fm=webp&auto=compress&w=559&q=90&dpr=2&updated_at=1741361073"
// ... more images ...
],
"updated_at": "2025-12-07T05:05:22Z",
"created_at": "2025-12-07T05:05:22Z",
"link": "https://stockx.com/air-jordan-1-retro-high-og-rare-air",
"rank": 452,
"weekly_orders": 82,
"country_of_manufacture": "CN",
"primary_title": "Jordan 1 Retro High OG",
"secondary_title": "Rare Air",
"min_price": 78,
"max_price": 417,
"avg_price": 148.125,
"short_description": "",
"upcoming": false
}
// ... more products ...
],
"meta": {
"current_page": 1,
"per_page": 20,
"total": 1000
}
}
```
You can use the `id` or `slug` parameter to get a product by its ID or slug.
```http theme={null}
GET https://api.kicks.dev/v3/stockx/products/[ID_or_SLUG]
```
The response will be the product data, like this:
```json theme={null}
{
"data": {
"id": "2f15e74e-7d99-44a3-8ecb-04fe09bc4116",
"title": "Nike SB Dunk Low Fog",
"brand": "Nike",
"model": "Nike SB Dunk Low",
"gender": "men",
"description": "The Nike Dunk SB Low Fog is a skateboarding sneaker that slightly resembles the Nike Dunk SB High Fog released in 2005...",
"image": "https://images.stockx.com/images/Nike-Dunk-SB-Low-Fog-Product.jpg?fit=fill&bg=FFFFFF&w=700&h=500&fm=webp&auto=compress&q=90&dpr=2&trim=color&updated_at=1738193358",
"sku": "BQ6817-010",
"slug": "nike-dunk-sb-low-fog",
"product_type": "sneakers",
"category": "Nike SB",
"secondary_category": "SB Dunk Low",
"categories": ["sneakers"],
"breadcrumbs": [
{
"value": "Sneakers",
"alias": "sneakers",
"level": 1
},
{
"value": "Performance",
"alias": "performance",
"level": 2
}
],
"gallery": [
"https://images.stockx.com/images/Nike-Dunk-SB-Low-Fog-Product.jpg?fit=fill&bg=FFFFFF&w=700&h=500&fm=webp&auto=compress&q=90&dpr=2&trim=color&updated_at=1738193358"
],
"gallery_360": [
"https://images.stockx.com/360/Nike-Dunk-SB-Low-Fog/Images/Nike-Dunk-SB-Low-Fog/Lv2/img01.jpg?fm=webp&auto=compress&w=559&q=90&dpr=2&updated_at=1635539965"
// ... more images ...
],
"updated_at": "2025-12-07T07:22:08Z",
"created_at": "2025-12-07T07:22:08Z",
"link": "https://stockx.com/nike-dunk-sb-low-fog",
"rank": 2201,
"weekly_orders": 18,
"country_of_manufacture": "VN",
"primary_title": "Nike SB Dunk Low",
"secondary_title": "Fog",
"min_price": 154,
"max_price": 440,
"avg_price": 228.1,
"short_description": "",
"upcoming": false
},
"meta": null
}
```
## Additional parameters
Get the variants of the product
Get the prices of the product
Get the identifiers of the product
### Getting product variants
You can add the `display[variants]` parameter to get the variants of the product, it will return a new field `variants` in the product data, like this:
Request example:
```http theme={null}
GET https://api.kicks.dev/v3/stockx/products/[ID_or_SLUG]?display[variants]=true
```
Response example:
```json theme={null}
{
// ... product data ...
"variants": [
{
"id": "376f06bc-33a1-494e-a337-124ad80b3ddc",
"size": "4",
"size_type": "us m",
"sizes": [
{
"size": "US M 4",
"type": "us m"
},
{
"size": "UK 3.5",
"type": "uk"
},
{
"size": "CM 23",
"type": "cm"
},
{
"size": "KR 230",
"type": "kr"
},
{
"size": "EU 36",
"type": "eu"
},
{
"size": "US W 5.5",
"type": "us w"
}
],
"lowest_ask": 194,
"total_asks": 3,
"position": 0,
"hidden": false,
"updated_at": "2025-12-07T07:22:08Z",
"identifiers": null,
"prices": null,
"currency": "USD",
"market": "US",
"sales_count_15_days": 1,
"sales_count_30_days": 1,
"sales_count_60_days": 1
}
// ... more variants ...
]
}
```
### Getting all product prices
You can add the `display[prices]` parameter to get the prices of the product, it will return a new field `prices` in each individual `variant`, containing the lowest ask, ask count per delivery option.
Request example:
```http theme={null}
GET https://api.kicks.dev/v3/stockx/products/[ID_or_SLUG]?display[prices]=true
```
Response example:
```json theme={null}
{
// ... variant data ...
"prices": [
{
"price": 339,
"asks": 6,
"type": "standard"
}
]
}
```
Supported delivery options are:
* `standard`
* `express_standard` (StockX Flex)
* `express_expedited` (StockX Flex)
### Getting product identifiers
Paying users only
You can add the `display[identifiers]` parameter to get the identifiers of the product, it will return a new field `identifiers` in each individual `variant`, containing the identifiers of the product, like this:
Request example:
```http theme={null}
GET https://api.kicks.dev/v3/stockx/products/[ID_or_SLUG]?display[identifiers]=true
```
Response example:
```json theme={null}
{
// ... variant data ...
"identifiers": [
{
"identifier": "198483486005",
"identifier_type": "UPC"
}
]
}
```
# Get sales history from StockX
Source: https://docs.kicks.dev/recipes/stockx-get-sales
How to get the sales history of a product from StockX using KicksDB
In order to get the sales history of a product, you need to know the ID or slug of the product. Follow the [Get a product from StockX recipe](/recipes/stockx-get-product) to get the ID or slug of the product.
Get the sales history of the product
Get the daily aggregated sales history of the product
The following endpoint returns the sales history of the product, including the sale price, date and variant sold.
```http theme={null}
GET https://api.kicks.dev/v3/stockx/products/[ID_or_SLUG]/sales
```
Response example:
```json theme={null}
{
"$schema": "https://api.kicks.dev/schemas/RespListVariantSaleBody.json",
"data": [
{
"product_id": "fb1a8a7d-5be4-4f0e-a4b5-bf0a735ab7fe",
"variant_id": "3763432c-8ea7-43e7-a4fe-744c0ad89797",
"amount": 247,
"created_at": "2025-12-07T09:10:19Z"
},
{
"product_id": "fb1a8a7d-5be4-4f0e-a4b5-bf0a735ab7fe",
"variant_id": "7f3c7ac8-82d8-4da6-ac04-abf099f1ee0b",
"amount": 350,
"created_at": "2025-12-07T08:59:44Z"
}
// ... more sales ...
]
}
```
## Additional parameters
### Getting sales history by variant
You can add the `variant_id` parameter to get the sales history of a specific variant, like this:
```http theme={null}
GET https://api.kicks.dev/v3/stockx/products/[ID_or_SLUG]/sales?variant_id=[VARIANT_ID]
```
Response example:
```json theme={null}
{
"$schema": "https://api.kicks.dev/schemas/RespListVariantSaleBody.json",
"data": [
{
"product_id": "fb1a8a7d-5be4-4f0e-a4b5-bf0a735ab7fe",
"variant_id": "3763432c-8ea7-43e7-a4fe-744c0ad89797",
"amount": 247,
"created_at": "2025-12-07T09:10:19Z"
},
{
"product_id": "fb1a8a7d-5be4-4f0e-a4b5-bf0a735ab7fe",
"variant_id": "3763432c-8ea7-43e7-a4fe-744c0ad89797",
"amount": 353,
"created_at": "2025-12-07T02:59:45Z"
}
// ... more sales ...
]
}
```
You can use the `/daily` endpoint to get the daily aggregated sales history of the product, like this:
```http theme={null}
GET https://api.kicks.dev/v3/stockx/products/[ID_or_SLUG]/sales/daily
```
Response example:
```json theme={null}
{
"$schema": "https://api.kicks.dev/schemas/RespListProductSaleBody.json",
"data": [
{
"product_id": "fb1a8a7d-5be4-4f0e-a4b5-bf0a735ab7fe",
"avg_amount": 261.9866666666667,
"orders": 75,
"date": "2025-12-07T00:00:00Z"
},
{
"product_id": "fb1a8a7d-5be4-4f0e-a4b5-bf0a735ab7fe",
"avg_amount": 257.63013698630135,
"orders": 292,
"date": "2025-12-06T00:00:00Z"
},
{
"product_id": "fb1a8a7d-5be4-4f0e-a4b5-bf0a735ab7fe",
"avg_amount": 249.17842323651453,
"orders": 241,
"date": "2025-12-05T00:00:00Z"
}
// ... more daily sales ...
]
}
```
# StockX API with JavaScript
Source: https://docs.kicks.dev/recipes/stockx-javascript
Collecting products from StockX API using KicksDB and JavaScript
Requesting products from StockX API is straightforward using KicksDB and `fetch` API in JavaScript.
```js theme={null}
const API_KEY = "your-api-key";
const URL = "https://api.kicks.dev/v3/stockx/products";
const params = new URLSearchParams({
query: "Nike Dunk SB Low Fog",
});
const response = await fetch(`${URL}?${params.toString()}`, {
headers: {
Authorization: `Bearer ${API_KEY}`,
},
});
const data = await response.json();
for (const product of data.data) {
console.log(`${product.title} - ${product.sku}`);
}
```
It should output something like this:
```log theme={null}
Nike SB Dunk Low Fog - BQ6817-010
Nike SB Dunk Low Black Midnight Fog - 304292-025
Nike SB Dunk Low Obsidian Midnight Fog Black - 304292-403
Nike SB Dunk Low Supreme 94 Ocean Fog - HQ8487-400
Nike Dunk SB Low Krampus - HV1668-001
Nike SB Dunk Low Mummy - DM0774-111
Nike SB Dunk Low Piet Mondrian - 304292-702
...
```
## Recommendations
* Avoid storing API key in your code, use environment variables instead (`process.env`).
* More parameters can be added to the request, see the [API reference](https://api.kicks.dev/docs#tag/stockx/get/v3stockxproducts) for more information.
* Prefer `async/await` over `then/catch` for better readability.
* You might be interested in [OpenAPI Generator](https://openapi-generator.tech/) to generate client libraries for your favorite programming language, it might help you to interact with the API in a more convenient way.
# Search products from multiple platforms
Source: https://docs.kicks.dev/recipes/unified-api-search
How to search products from multiple platforms using KicksDB
KicksDB aggregates data from multiple platforms and cross-matches them to provide a unified view of the product.
It's useful when you want to compare prices, images, and overall data of a product.
In December 2025, we have over 1.6M products in our database and around 340k of them posses at least one related product on another platform.
We keep improving our cross-matching algorithm to provide the most accurate results.
Search products from multiple platforms
API Reference
Premium Feature
You can search for a product by its SKU, Product ID or Slug. Slug is the recommended way to search for a product because SKU might have special characters or spaces and Product ID might overlap other products from different platforms.
Request example:
```http theme={null}
GET https://api.kicks.dev/v3/unified/products/air-jordan-4-retro-white-cement-2025
```
Response example:
```json theme={null}
{
"$schema": "https://api.kicks.dev/schemas/RespListUnifiedProductBody.json",
"data": [
{
"shop_name": "flightclub",
"slug": "air-jordan-4-retro-og-white-cement-2025-fv5029-100",
"source_product_id": "1487425",
"name": "Jordan 4 Retro OG 'White Cement' 2025",
"brand": "Air Jordan",
"model": "Air Jordan 4",
"images": [
"https://cdn.flightclub.com/TEMPLATE/463428/1.jpg",
"https://cdn.flightclub.com/TEMPLATE/463428/2.jpg",
"https://cdn.flightclub.com/TEMPLATE/463428/3.jpg",
"https://cdn.flightclub.com/TEMPLATE/463428/4.jpg"
],
"sku": "FV5029 100",
"link": "https://www.flightclub.com/air-jordan-4-retro-og-white-cement-2025-fv5029-100",
"prices": {
"4": 396,
"5": 2059,
"6": 2589,
"7": 269,
"8": 265,
"9": 262,
"10": 265,
"11": 285,
"12": 278,
"13": 274,
"14": 279,
"15": 299,
"16": 331,
"17": 240,
"18": 248,
"10.5": 281,
"11.5": 271,
"12.5": 294,
"3.5": 2589,
"4.5": 2589,
"5.5": 2589,
"6.5": 2059,
"7.5": 263,
"8.5": 270,
"9.5": 264
},
"barcodes": [
"197863039336",
"197863037004",
"197863038216",
"197863038131",
"197863040806",
"197863037196",
"197863038551",
"197863038162",
"197863037172",
"197863036434",
"197863035918",
"197863038834",
"197863039695",
"197863042206",
"197863036557",
"197862966572",
"197862977059",
"197863040479",
"197863038414",
"197863038902"
],
"product_type": "sneakers",
"metadata": {
"cluster_id": "b1e9d0bbec398180",
"colorway": "Summit White/Fire Red/Tech Grey/Black",
"release_date": "2025-05-24T23:59:59.999Z"
},
"updated_at": "2025-12-08T09:07:58Z"
},
{
"shop_name": "flightclub",
"slug": "air-jordan-4-retro-og-gs-white-cement-2025-ib4171-100",
"source_product_id": "1557903",
"name": "Jordan 4 Retro OG GS 'White Cement' 2025",
"brand": "Air Jordan",
"model": "Air Jordan 4",
"images": [
"https://cdn.flightclub.com/TEMPLATE/489647/1.jpg",
"https://cdn.flightclub.com/TEMPLATE/489647/2.jpg",
"https://cdn.flightclub.com/TEMPLATE/489647/3.jpg",
"https://cdn.flightclub.com/TEMPLATE/489647/4.jpg"
],
"sku": "IB4171 100",
"link": "https://www.flightclub.com/air-jordan-4-retro-og-gs-white-cement-2025-ib4171-100",
"prices": {
"4": 158,
"5": 179,
"6": 212,
"7": 223,
"3.5": 166,
"4.5": 165,
"5.5": 216,
"6.5": 229
},
"barcodes": [
"197862988819",
"197862989427",
"197862988185",
"197862977059",
"197862985689",
"197862966572",
"197862973013",
"197862983746"
],
"product_type": "sneakers",
"metadata": {
"cluster_id": "b1e9d0bbec398180",
"colorway": "White/Tech Grey/Black/Fire Red",
"release_date": "2025-05-24T23:59:59.999Z"
},
"updated_at": "2025-12-08T09:07:58Z"
},
// ... more products ...
],
"meta": null
}
```
## Remarks
* Our algorithm uses only deterministic identifiers in order to avoid false-positives, however, this does not guarantee 100% accuracy.
* You can use the `similarity` parameter to filter products with a similarity score in addition to the existing cross-matching algorithm. The default threshold is 0.85.
* Some products might have multiple matches in the same platform, this can happen for multiple reasons:
* The platform did not tag the product with the correct identifier
* The product might have GS, TD variants with same identifiers