Looking for the overview — what this API returns, what it costs, and a call you can run without a key? See the momox second-hand API page →
docs / momoxfashion

momox second-hand

momox second-hand

base /momoxfashion/v17 endpoints
post/momoxfashion/v1/detail3 credits

Everything one item publishes. The complete offer table straight from the shop's own product endpoint: on books one offer per condition grade with its own price and its own stock (ISBN 9782070584925 publishes four — like new 7.49 sold out, very good 5.79, good 4.01, acceptable 3.99 — and all 12 titles measured published more than one), on fashion the single offer behind the single garment, which is all there is: 12 of 12 garments measured carried exactly one. `price_min`, `price_min_available` and a per-grade price table are all returned, because the cheapest grade is sometimes the sold-out one. On fashion the item's page is read as well for the things only it carries — momox's OWN measurements of that garment in centimetres, its exact colour, its material list, its feature list, its condition grade in momox's words and its article number. The page's schema.org block is read as an independent price witness on both storefronts and any disagreement is reported in `meta.schema_org_cross_check` rather than hidden: it agreed with the live price on 12 of 12 garments, and on books it quotes the storefront's DEFAULT grade, which was the cheapest published offer on only 3 of 12 titles — a third number with a third meaning, explained instead of flattened. Reachable by handle, by a full product URL, or on books by ISBN-13, ISBN-10 or EAN. An unknown handle is NOT_FOUND.

ParameterAllowed / rangeDescription
storefront = fashionoptionalfashion · booksWhich momox storefront to read. The two shops run the same platform (Shopify plus a Constructor.io search index) but hold different things and spell their own filter values differently — `fashion` grades an item `very good` and `books` grades it `Very good`, and the source answers the wrong spelling with 0 results and HTTP 200 rather than an error. Every value sent here is therefore folded to the storefront's own spelling and checked against the source's own echo. Filters that one shop does not offer are rejected with the list it does offer, never silently ignored.
handleoptional—Which item to open, by the storefront's own handle — the part of the URL after /products/. A full momoxfashion.com or momoxbooks.com product URL is also accepted and the handle is taken out of it. Every `search`, `suggest` and `latest` row returns it as `handle` and as ready-made `detail_params`. The handle is self-describing: on `fashion` it ends with the garment's own UUID and on `books` with the ISBN-13 or EAN, so `isbn` is an alternative way in. An unknown handle is NOT_FOUND (the source answers HTTP 404 for one).
isbnoptional—Open a books item by its ISBN-13 or EAN instead of its handle — books only. The shop's own handle ends with exactly this number, but the slug in front of it is not derivable, so the code is resolved through momox's own index first and then read from the product itself (two requests). An ISBN-10 is converted to ISBN-13 before the lookup, and a code the shop has never carried is NOT_FOUND.
include_attributes = trueoptional—Also read the item's own page for the things only it publishes: on `fashion` momox's OWN MEASUREMENTS of the garment in centimetres (chest, shoulder, total length, waist, inseam — whichever apply to the garment class), its exact colour, its material list, its feature list and its condition grade in momox's words; on both storefronts the page's schema.org block, which is read as an independent price witness and reported in `meta.schema_org_cross_check`. It costs one extra request. Switch it off for the price and stock table alone.
include_pii = falseoptional—Accepted for gateway compatibility. There is no personal data on either storefront: momox is the only seller, it owns every item it lists, and no customer, reviewer or third-party seller is published anywhere.
Try in playground →
post/momoxfashion/v1/facets2 credits

momox's own inventory census: every value its search engine offers for a query or a shelf, with ITS OWN item count beside each one. This is how you learn the vocabulary before filtering, and it is the only honest source of it, because the source matches filter values case-sensitively and answers a mis-spelled one with 0 items and HTTP 200. Fashion publishes 14 facets plus price — 187 size values for the keyword `jacke`, 1,848 brands, colour family, condition, material, length, fit, neckline, sleeve length, pattern, closure, fabric texture, details, heel height — and books 7: condition, author/artist, format, platform, language, medium and in-stock. It is also a census in its own right: `jacke` reports like new 68,528 against very good 100,895 and good 27, which is momox's grading mix for jackets in one number.

ParameterAllowed / rangeDescription
storefront = fashionoptionalfashion · booksWhich momox storefront to read. The two shops run the same platform (Shopify plus a Constructor.io search index) but hold different things and spell their own filter values differently — `fashion` grades an item `very good` and `books` grades it `Very good`, and the source answers the wrong spelling with 0 results and HTTP 200 rather than an error. Every value sent here is therefore folded to the storefront's own spelling and checked against the source's own echo. Filters that one shop does not offer are rejected with the list it does offer, never silently ignored.
qoptional—Free-text search, run by momox's own search engine — not by this API. On `fashion` it matches brand, garment type, colour and material: `nike jacke` returned 25,989 items and `jacke` alone 170,726 on 2026-10-08. On `books` it matches title, author and performer: `harry potter` returned 4,403. Leave it out to browse a shelf instead, with `category`. A keyword and a `category` can be combined — unlike the group's media storefronts, this source really does honour both at once (measured: `jacke` 170,726 -> 33,641 inside men's clothing -> 13,135 inside men's jackets).
categoryoptional—Browse one shelf of momox's own taxonomy, by the id the `categories` action lists. On `fashion` the id IS the structured token the shop puts in every product's `product_type` — `gender_female`, `gender_female.titlecat_clothing`, `gender_female.titlecat_clothing.maincat_outerwear.subcat_jacket_coat` — so every search row hands back its own shelf, parsed into gender / category / subcategory, ready to pass straight back in. On `books` the ids are hyphenated instead (`books`, `books-fiction`, `books-english-books`) and a product can sit in several at once. An id that does not exist returns 0 items with HTTP 200 at the source, so the id is checked against the live tree and a typo comes back as NOT_FOUND.
filtersoptional—Narrow the result with momox's own facets, as {filter: value} or {filter: [values]}. `fashion` offers size, brand, color, condition, material, length, fit, neckline, sleeve_length, pattern, closure, fabric_texture, details and heel_height; `books` offers condition, creator, format, platform, language, medium and in_stock. Several values of one filter are a UNION (size [INT M, INT L] returned 77,358 against 55,466 and 77,358 is not their sum) and two different filters are an INTERSECTION (size INT M + brand Nike = 151). Use `facets` to see every value the source offers with its own item count, because the vocabulary is the source's own: sizes are spelled `INT M`, `EU 38`, `W35`, colours as a family (`Black`, `Multi`), materials in English (`Cotton`, `No label`). Values are matched CASE-SENSITIVELY at the source (`nike` returned 0 items and `Nike` 475, both HTTP 200), so each one sent is checked against the source's own echo of what it applied and anything it did not apply is reported in `meta.filters_not_applied` instead of passing as a successful narrowing.
min_priceoptional0–Lowest price, in EUR MAJOR units (10 = EUR 10.00, not 1000). Sent to the source as its own price-range filter, so the narrowing is momox's, not ours (measured: 10-20 EUR cut the keyword `jacke` from 170,726 to 25,274). Live fashion prices ran EUR 5.99 to 740.90.
max_priceoptional0–Highest price, same units as `min_price`. Combine the two for a band. The source takes a bounded range, so giving only one side still works — the other end is left open.
include_pii = falseoptional—Accepted for gateway compatibility. There is no personal data on either storefront: momox is the only seller, it owns every item it lists, and no customer, reviewer or third-party seller is published anywhere.
Try in playground →
post/momoxfashion/v1/categories1 credit

momox's whole category tree with its own item count on every node and the Shopify collection handle that serves it. On fashion the node id IS the structured token the shop stamps on every product, so the tree, the search filter and each row's own `category` field are one and the same vocabulary: All 1,854,875 -> Damen 1,515,748 -> Bekleidung 1,377,790 -> and down to Handtaschen 8,724. On books it is All 12,130,377 -> Books 10,460,867 -> Professional & Reference 4,385,001 and so on. Walk from any node with `root` and control the depth; depth 1 is the cheapest way to see the shape of the catalogue. These counts are the source's own index counts, not a live buyable count — the `collections` action's numbers are a different and less reliable thing, and both are labelled as what they are.

ParameterAllowed / rangeDescription
storefront = fashionoptionalfashion · booksWhich momox storefront to read. The two shops run the same platform (Shopify plus a Constructor.io search index) but hold different things and spell their own filter values differently — `fashion` grades an item `very good` and `books` grades it `Very good`, and the source answers the wrong spelling with 0 results and HTTP 200 rather than an error. Every value sent here is therefore folded to the storefront's own spelling and checked against the source's own echo. Filters that one shop does not offer are rejected with the list it does offer, never silently ignored.
root = alloptional—Which node to walk from, by its id. The default `all` is the whole catalogue. Pass a gender (`gender_female`, 1,515,748 items) or any node the tree returns to get just that branch with its own counts.
depth = 3optional1–4How deep into the category tree to walk, 1-4. The fashion tree is 4 levels (All -> gender -> clothing/accessories/shoes -> main category -> subcategory) and the books tree 3. Depth 1 is the top shelves alone with their item counts, which is the cheapest way to see the shape of the catalogue.
include_pii = falseoptional—Accepted for gateway compatibility. There is no personal data on either storefront: momox is the only seller, it owns every item it lists, and no customer, reviewer or third-party seller is published anywhere.
Try in playground →
post/momoxfashion/v1/collections1 credit

Every collection the Shopify storefront publishes, with handle, title, description, image and ready-made `feed_params`. This is the list of shelves the shop's own navigation uses, and the handles are what `latest` reads a feed from. The count the source attaches to each one is published as `products_count_claimed` and nothing else, because it is not a live number: momoxbooks publishes hundreds of `by-<artist>` collections whose count is 0, and the Shopify count includes products that can no longer be bought. Use `categories` for a count you can rely on, or `search` for the live match count.

ParameterAllowed / rangeDescription
storefront = fashionoptionalfashion · booksWhich momox storefront to read. The two shops run the same platform (Shopify plus a Constructor.io search index) but hold different things and spell their own filter values differently — `fashion` grades an item `very good` and `books` grades it `Very good`, and the source answers the wrong spelling with 0 results and HTTP 200 rather than an error. Every value sent here is therefore folded to the storefront's own spelling and checked against the source's own echo. Filters that one shop does not offer are rejected with the list it does offer, never silently ignored.
qoptional—Keep only collections whose handle, title or description contains this text (case-insensitive). Applied by this API over the list the source returned.
limit = 250optional1–250How many collections to return, 1-250 — the source's own page size.
page = 1optional1–40Which page of the collection list to read. momoxbooks publishes hundreds of `by-<artist>` collections, so paging matters there.
include_pii = falseoptional—Accepted for gateway compatibility. There is no personal data on either storefront: momox is the only seller, it owns every item it lists, and no customer, reviewer or third-party seller is published anywhere.
Try in playground →
post/momoxfashion/v1/latest2 credits

The shop's live product feed, newest first, straight from its own catalogue endpoint — 250 items per request with the authoritative price, the crossed-out price where there is a real one, the stock flag and every image. This is the surface that settles the price question: 2,000 of 2,000 fashion rows measured carried a real price, while 1,992 of them carried `compare_at_price` as the string "0.00" (dropped to null here), and on books the 105 of 1,017 variants whose price is "0.00" are exactly the ones with no copy in stock, published as `offer_status: no_copy_in_stock` and a null price rather than as a free book. Use it to watch what momox listed today — page 1 was published the same morning it was measured — or to read one Shopify collection's feed. Note that this endpoint honours only `limit` and `page`: every filter and sort parameter it advertises was measured returning the identical 50 product ids in the identical order, so all real searching belongs in `search`.

ParameterAllowed / rangeDescription
storefront = fashionoptionalfashion · booksWhich momox storefront to read. The two shops run the same platform (Shopify plus a Constructor.io search index) but hold different things and spell their own filter values differently — `fashion` grades an item `very good` and `books` grades it `Very good`, and the source answers the wrong spelling with 0 results and HTTP 200 rather than an error. Every value sent here is therefore folded to the storefront's own spelling and checked against the source's own echo. Filters that one shop does not offer are rejected with the list it does offer, never silently ignored.
collectionoptional—Read one Shopify collection's feed instead of the whole shop. The `collections` action lists the handles and every `categories` node carries the handle of the collection that serves it. A handle that does not exist is NOT_FOUND — the catalogue endpoint answers one with an empty list and HTTP 200, exactly like a real but empty collection, so it is checked against /collections/<handle>.json separately.
limit = 50optional1–250How many products to return, 1-250 — 250 is the source's own clamp (it answers limit=300 with the same 250 rows).
page = 1optional1–1000Which page of the feed, 1-based, passed straight to the source. The feed is newest first: on 2026-10-08 page 1 was published that same morning and pages 2-8 the previous day, so a few pages are a precise 'what arrived today'.
include_pii = falseoptional—Accepted for gateway compatibility. There is no personal data on either storefront: momox is the only seller, it owns every item it lists, and no customer, reviewer or third-party seller is published anywhere.
Try in playground →
post/momoxfashion/v1/suggest1 credit

The storefront's own autocomplete: what momox suggests as you type. Returns both the suggested SEARCH TERMS (`nike` -> `nike damen`), each with ready-made `search_params`, and the matching ITEMS in full — on fashion already carrying price, condition, exact colour, material, size and the taxonomy token, so a single cheap request answers 'what does momox have for this phrase' without a full search. One upstream request, no wall in front of it.

ParameterAllowed / rangeDescription
storefront = fashionoptionalfashion · booksWhich momox storefront to read. The two shops run the same platform (Shopify plus a Constructor.io search index) but hold different things and spell their own filter values differently — `fashion` grades an item `very good` and `books` grades it `Very good`, and the source answers the wrong spelling with 0 results and HTTP 200 rather than an error. Every value sent here is therefore folded to the storefront's own spelling and checked against the source's own echo. Filters that one shop does not offer are rejected with the list it does offer, never silently ignored.
qoptional—Free-text search, run by momox's own search engine — not by this API. On `fashion` it matches brand, garment type, colour and material: `nike jacke` returned 25,989 items and `jacke` alone 170,726 on 2026-10-08. On `books` it matches title, author and performer: `harry potter` returned 4,403. Leave it out to browse a shelf instead, with `category`. A keyword and a `category` can be combined — unlike the group's media storefronts, this source really does honour both at once (measured: `jacke` 170,726 -> 33,641 inside men's clothing -> 13,135 inside men's jackets).
limit = 8optional1–20How many items per section, 1-20.
include_pii = falseoptional—Accepted for gateway compatibility. There is no personal data on either storefront: momox is the only seller, it owns every item it lists, and no customer, reviewer or third-party seller is published anywhere.
Try in playground →
Built for volume
5M+ requests a day

Measured at 60 requests a second across the fleet, with no central bottleneck. Volume pricing is on request, and per-key limits are raised for high-volume accounts.

Missing a source?
We build it

Tell us a site we do not cover yet and it becomes an engine. A customer asked for bestprice.gr on a Sunday and it was in the catalog the next day.

Support
2 minute median reply

Median time from a question in the live chat to the first answer, measured across every answered conversation. Setup help included, no support tier to buy.

One key, one balance
Every API included

No per-site plans and no separate subscriptions. One key and one credit pool across the whole catalog, so adding a source costs nothing up front.

Planning something large? Tell us the volume and the sources and we will come back with what it costs and what we would have to build.