# KREAM Scraper - Sneakers, Prices, Bids & Market Data (`abotapi/kream-scraper`) Actor

Scrape KREAM (kream.co.kr) sneaker and fashion resale data by keyword search, filters, sorts, or product URLs. Extract 34+ fields, including lowest ask, highest bid, market price, premium, retail price, style code, sizes, and optional price history.

- **URL**: https://apify.com/abotapi/kream-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Features:** Limited permissions
- **Stats:** 25 total users, 4 monthly users, 94.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 product results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## KREAM Scraper: Sneaker & Streetwear Resale Prices

KREAM Scraper turns KREAM (kream.co.kr), Korea's sneaker and streetwear resale marketplace, into a clean pricing data feed. Search by keyword or paste product and search links to get lowest ask, highest bid, market price, premium, retail price, style code, release date, sizes and wish counts for every result, then export to JSON, CSV or Excel, or pull the results straight into your app through the API.

### Why This Scraper?

- **Two ways to find products.** Search by keyword, or paste KREAM product and search links directly.
- **Market data on every result.** Lowest ask, highest bid, market price, last sale, premium and total sales come back with the base listing, no separate detail fetch needed.
- **Full listing detail out of the box.** Style code, colorway, release date, retail price, every size and the full image set are already included.
- **Optional deep detail.** Turn on Fetch full details for price history, per-size ask/bid inventory and recent sales, asks and bids, plus up to 100 reviews per product nested on the row.
- **Eleven sort orders and five filters.** Order by popularity, price, premium, wish count or release date, and narrow by quick delivery, below-retail, sold-out status, category or gender, in either mode.
- **Built for schedules.** Incremental mode returns only new and changed products on recurring runs, and a refused run ends with a clear BLOCKED status message, so it is never mistaken for a search with no matches.
- **Resume large crawls.** Continue an interrupted or capped run without paying twice for products already collected.

### Use Cases

- **Resale price tracking and arbitrage:** watch lowest ask, highest bid and premium across sneakers and streetwear to spot mispriced listings.
- **Market research and trend analysis:** build historical datasets of prices, wish counts and sales volume by brand or category.
- **Drop and release monitoring:** track new releases and price movement in the period after launch.
- **Inventory and pricing tools:** feed live ask/bid data into a reseller's own pricing or listing tool.
- **Fashion and sneaker media:** source current market prices and premiums for articles and price guides.

### Data You Get

> Sample shape: values are illustrative placeholders, not from a live record.

| Field | Example |
| --- | --- |
| `productId` | `30001` |
| `url` | KREAM link to the product |
| `productName` / `productNameKo` | `"Nike Dunk Low Retro Black"` / `"나이키 덩크로우 레트로 블랙"` |
| `brand` / `brandId` | `"Nike"` / `1` |
| `category` / `categoryName` | `"sneakers"` / `"스니커즈"` |
| `styleCode` | `"DD1391-100"` |
| `colorway` / `gender` | `"BLACK/WHITE"` / `"men"` |
| `releaseDate` | `"2024-01-20"` |
| `retailPrice` / `retailPriceFormatted` | `109000` / `"109,000원"` |
| `productNameEn` / `productUrl` / `modelNumber` / `releasePrice` / `price` | Alias names for drop-in use: same values as `productName` / `url` / `styleCode` / `retailPrice` / `lowestAsk` |
| `currency` | `"KRW"` |
| `imageUrl` / `imageUrls` | main product photo / the full image set |
| `lowestAsk` / `highestBid` | `135000` / `128000` |
| `marketPrice` / `lastSalePrice` | `132000` / `130000` |
| `totalSales` | `842` |
| `changeValue` / `changePercentage` | `2000` / `1.5` |
| `premium` / `premiumPercentage` | `26000` / `23.9` |
| `hasImmediateDelivery` | `true` |
| `wishCount` / `reviewCount` / `haveCount` | `5210` / `312` / `890` |
| `isActive` / `isTradable` | `true` / `true` |
| `sizes` / `sizeOptions` | `["250","260","270","280"]` / per-size id, key and display name |
| `priceHistory` / `inventoryBySize` | price series by time span and per-size ask/bid (when Fetch full details is on, and always for pasted product URLs) |
| `recentSales` / `recentAsks` / `recentBids` | most recent trade rows (when Fetch full details is on, and always for pasted product URLs) |
| `reviews` | nested review rows, each with `reviewId`, `reviewer`, `reviewerId`, `rating`, `purchasedSize`, `wearerInfo`, `fitSurvey`, `reviewDate`, `helpfulCount` (and `text` when a review carries free text). Added when Fetch full details is on and Reviews per product is above 0. KREAM reviews are a rating plus a size and fit survey, so most carry no free-text body and none carry seller replies |
| `changeType` / `changedFields` / `firstSeenAt` / `lastSeenAt` | `"NEW"` / `[]` / run timestamps (incremental mode only) |

Prices are in KRW. A product marked `EXPIRED` (incremental mode only) carries the same fields as its last successful scrape, unchanged, plus the `changeType` and timestamp fields above.

#### Output views

The Output tab offers four tables: **Products** (overview), **Detail** (price history, per-size ask/bid and recent sales, asks and bids; filled when detail mode is on), **Reviews** (the nested reviews; filled when detail mode is on and Reviews per product is above 0) and **Changes** (change type, changed fields, first and last seen; filled in incremental mode).

### How to Use

1. Pick a **mode**: `search` (by keyword) or `url` (paste KREAM product or search links).
2. Fill in keywords or URLs, and set the sort and filters you want; they apply in both modes.
3. Turn on **Fetch full details** if you need price history and per-size inventory, and set **Max items** to control run size and cost.
4. Click **Start**, then download the dataset as JSON, CSV or Excel, or read it through the API.

#### URL mode: supported links

URL mode behaviour change: the `urls` field now ships with one example of every supported link type below, so a URL-mode run started with the field untouched scrapes one example of each (7 sources) instead of a single product. Clear the field and paste your own links to scrape only those.

| Link type | Example | What you get |
|---|---|---|
| Keyword search | `https://kream.co.kr/search?keyword=nike` | Matching products, paged automatically |
| Korean keyword (percent-encoded or plain) | `https://kream.co.kr/search?keyword=%EB%82%98%EC%9D%B4%ED%82%A4` | Matching products |
| Search with category | `https://kream.co.kr/search?keyword=nike&category_id=1` | Products narrowed to that KREAM category id |
| Search with sort and tab | `https://kream.co.kr/search?keyword=nike&sort=date_released&tab=products` | Products in the sort written in the link (`gender` works the same way) |
| Product page | `https://kream.co.kr/products/23879` | One product in full detail |
| Product page with size (not in the default list) | `https://kream.co.kr/products/23879?size=270` | The same product in full detail; the size query is ignored and the log says so |
| Search on the www host | `https://www.kream.co.kr/search?keyword=jordan&tab=products` | Matching products (the www host is treated like kream.co.kr) |
| Brand page | `https://kream.co.kr/brands/nike` | The brand's products, paged automatically |

A sort, category id or gender written inside a link applies to that link only and wins over the matching input field; the other sort and filter fields still apply. A `page=N` (or `cursor=N`) in a search link starts at that page, and because earlier pages are not scanned it is not a full scan, so it never produces EXPIRED rows; a `shop_category_id` in a search link is ignored and the log says so (use `category_id` or the Category input). Links to other KREAM pages (the home page, exhibitions, old category paths) are skipped and the log says so. A run where any link was skipped or could not be resolved (an unsupported page, or a brand link whose brand is not found in KREAM's brand list) is not a full scan, so it never produces EXPIRED rows either.

**Basic keyword search:**

```json
{
  "mode": "search",
  "keywords": ["nike dunk", "jordan 1"],
  "maxItems": 20
}
```

**Filtered search: below retail, in stock, quick delivery:**

```json
{
  "mode": "search",
  "keywords": ["stussy"],
  "belowRetail": true,
  "excludeSoldOut": true,
  "quickDelivery": true,
  "sort": "premium_low",
  "maxItems": 30
}
```

**Paste KREAM product and search links:**

```json
{
  "mode": "url",
  "urls": [
    "https://kream.co.kr/products/23879",
    "https://kream.co.kr/search?keyword=asics"
  ],
  "maxItems": 40
}
```

**Daily incremental monitoring with full detail:**

```json
{
  "mode": "search",
  "keywords": ["yeezy"],
  "fetchDetails": true,
  "incrementalMode": true,
  "stateKey": "yeezy-daily",
  "maxItems": 100
}
```

#### Run it from your code

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("abotapi/kream-scraper").call(run_input={"mode": "search", "keywords": ["nike dunk"], "maxItems": 20})
for product in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(product["productName"], product["lowestAsk"])
```

JavaScript:

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('abotapi/kream-scraper').call({ mode: 'search', keywords: ['nike dunk'], maxItems: 20 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

Or connect it to Make, Zapier, n8n, Google Sheets or webhooks from the **Integrations** tab.

#### Resume and recurring updates

- **Resume** (`resumeFromRunId`) continues one interrupted or capped run: paste its run or dataset ID and the actor skips every product already collected there, so you don't pay twice.
- **Incremental mode** (`incrementalMode`) is for scheduled runs over the same search or URLs. Each product is classified `NEW`, `UPDATED` (with `changedFields`), `UNCHANGED` (suppressed and not billed unless `emitUnchanged` is on), `REAPPEARED` or `EXPIRED`. A product only becomes `REAPPEARED` if an earlier run had already marked it `EXPIRED`; `EXPIRED` itself is only produced after a run that reached the natural end of the tracked search, with `emitExpired` on, not capped by Max items, not a Resume, not blocked, with every link starting at page 1, and with every link scanned (none skipped or unresolved). `UPDATED` compares every output field with the previous run (price, ask, bid and wish-count moves are real signal; the alias fields `productNameEn`, `productUrl`, `modelNumber`, `releasePrice` and `price` are not compared on their own because they mirror `productName`, `url`, `styleCode`, `retailPrice` and `lowestAsk`, which are compared; nothing else is excluded by default) and `changedFields` lists what moved. `ignoreFieldsForChanges` excludes noisy fields (top-level names or dotted paths for nested ones) from that comparison while keeping them in the output; editing it never causes a one-time wave of `UPDATED` rows. `stateKey` names or shares the stored state; leave it empty to derive one automatically from the search scope (keywords or URLs, sort, filters and Fetch full details; Max items and Max pages are output caps and don't affect the key). Nested `reviews` are compared like any other field (add `reviews` to `ignoreFieldsForChanges` to keep review churn from marking a product `UPDATED`); the first run that starts delivering `reviews` for products already tracked does not report them as `UPDATED`. With incremental mode off, output is exactly as before.

### Send results into your apps (MCP connectors)

Optionally pipe the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. This is an extra delivery step after the scrape: the Apify dataset is never changed.

**What gets written to the connector:** a condensed, human-readable summary of each product, not the full JSON record. For Notion, each item becomes its own page with its name, brand, style code, lowest ask, highest bid, retail price, premium, release date, wish count and URL. Other connectors receive one combined digest of up to 25 items. The **complete record always stays in the Apify dataset**.

1. Authorize a connector once under **Apify → Settings → Integrations** (Notion, Linear, Airtable, or Apify).
2. Select it in the **"Pipe results into your apps"** input field. (If the picker is empty, you haven't authorized a connector yet.)
3. For **Notion**, also set `notionParentPageUrl` to the page where items should be created.

The connection is mediated by Apify's MCP proxy, so this actor never sees your third-party credentials. Leave the field empty to skip.

### Input Parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | string | `search` | `search` (keyword) or `url` (paste KREAM URLs). |
| `keywords` | array | `["nike"]` | Search terms. Search mode only; in URL mode the keyword is read from each pasted search URL instead. |
| `urls` | array | one example of each supported link type (see the URL mode table) | KREAM product, search or brand links (url mode). |
| `sort` | string | `popularity` | Order results: `popularity`, `lowest_ask`, `highest_bid`, `wish`, `style_tags` (most reviewed), `date_released`, `discount_rate`, `premium_high`, `premium_low`, `male_popularity`, `female_popularity`. Applies in both search mode and URL mode. |
| `quickDelivery` | boolean | `false` | Only products with KREAM Quick Delivery stock. Applies in both search mode and URL mode. |
| `belowRetail` | boolean | `false` | Only products whose lowest ask is below retail. Applies in both search mode and URL mode. |
| `excludeSoldOut` | boolean | `false` | Drop products with no live ask. Applies in both search mode and URL mode. |
| `category` | string | none | Optional KREAM category slug (e.g. `sneakers`). Applies in both search mode and URL mode. |
| `gender` | string | none (Any) | `men`, `women`, `kids`, or leave empty for any. Applies in both search mode and URL mode. |
| `fetchDetails` | boolean | `false` | Add price history, per-size ask/bid inventory and recent sales/asks/bids. |
| `maxReviewsPerProduct` | integer | `20` | Only with `fetchDetails`. Reviews nested on each product row under `reviews`; `0` skips reviews; clamped to a maximum of `100` (20 are served per request, so the default costs one extra request per product). |
| `maxItems` | integer | `20` | Stop after this many products across all keywords/URLs. `0` = unlimited; the schema accepts up to 100000. |
| `maxPages` | integer | `0` | Safety bound on result pages walked per keyword. `0` = no page limit; the run still stops at Max items. |
| `resumeFromRunId` | string | none | Continue one interrupted or capped run without re-collecting products already returned there. |
| `incrementalMode` | boolean | `false` | Return only new and changed products on recurring runs of the same search. |
| `stateKey` | string | none | Name or share an incremental-mode monitoring campaign. Leave empty to derive one from the search scope. |
| `emitUnchanged` | boolean | `false` | Incremental mode only. Also return (and bill) products marked `UNCHANGED`. |
| `emitExpired` | boolean | `false` | Incremental mode only. Also return (and bill) products marked `EXPIRED`, only after a run that fully scanned the tracked search. |
| `ignoreFieldsForChanges` | array | `[]` | Incremental mode only. Field names, or dotted paths for nested fields, to exclude from `UPDATED` detection and `changedFields`. The field stays in the output. |
| `proxy` | object | Apify Residential | Connection settings. |
| `mcpConnectors` | array | none | Optional: send a summary of each product to apps you authorized under Integrations. |
| `notionParentPageUrl` | string | none | Notion connector only: page under which items are created. |
| `maxNotifyListings` | integer | `50` | Cap on items written to each connector per run (non-Notion digests are further limited to 25). |

### Output Example

> Sample shape: values are illustrative placeholders, not from a live record.

```json
{
  "productId": 30001,
  "url": "https://kream.co.kr/products/30001",
  "productName": "Nike Dunk Low Retro Black",
  "productNameKo": "나이키 덩크로우 레트로 블랙",
  "brand": "Nike",
  "brandId": 1,
  "category": "sneakers",
  "categoryName": "스니커즈",
  "styleCode": "DD1391-100",
  "colorway": "BLACK/WHITE",
  "gender": "men",
  "releaseDate": "2024-01-20",
  "retailPrice": 109000,
  "retailPriceFormatted": "109,000원",
  "currency": "KRW",
  "imageUrl": "https://image.kream.co.kr/products/30001/main.jpg",
  "imageUrls": ["https://image.kream.co.kr/products/30001/main.jpg"],
  "lowestAsk": 135000,
  "highestBid": 128000,
  "marketPrice": 132000,
  "lastSalePrice": 130000,
  "totalSales": 842,
  "changeValue": 2000,
  "changePercentage": 1.5,
  "premium": 26000,
  "premiumPercentage": 23.9,
  "hasImmediateDelivery": true,
  "wishCount": 5210,
  "reviewCount": 312,
  "haveCount": 890,
  "isActive": true,
  "isTradable": true,
  "sizes": ["250", "260", "270", "280"],
  "sizeOptions": [
    { "id": 1, "key": "270", "name": "270", "displayName": "270" }
  ]
}
```

### Plan Requirement

KREAM gates its product API by request headers rather than by country, so no Korea pin is needed. Both datacenter and residential connections load most pages, so no particular proxy plan is required to try the actor. Apify Residential is optional and is still the default, because it is the most consistent; a few requests (for example some sorted or filtered result pages) can stall on a datacenter connection.

If the selected connection is unavailable to your run (for example Apify free plans, which do not include residential proxies), the run continues on a backup connection and the log says so:

- `The selected connection is unavailable to this run.` followed by `Continuing on a backup connection; some pages may still be unavailable.`
- `Served over the backup connection (the default connection was unavailable).` once a page loads that way.

If no page can be loaded at all, the run ends as failed with one of these messages instead of finishing with an empty dataset:

- `The proxy connection was refused for this account, so no page could be read. Your Apify plan does not include proxy access; a paid plan is required.`
- `No results: residential proxies are unavailable on this run (Apify free plans do not include them), and the backup connection could not load the requested KREAM pages.`
- `Could not load any results page (the requests failed), so nothing was collected. This is a connection problem, not an empty search. Please try again later.`

You can also choose another connection or your own proxy URLs under **Proxy configuration**.

### FAQ

#### How much does it cost?

You pay per product returned, plus a small per-run start fee. Detail enrichment is billed when **Fetch full details** is on, and for every pasted product URL, which always returns full detail. Reviews are billed on that same detail-enrichment event: one extra unit for every full or partial block of 10 reviews actually delivered on a returned product row (20 reviews = 2 extra units), counted only after the row is returned, never for a product that incremental mode suppresses as unchanged and never for reviews that were not delivered; set **Reviews per product** to 0 to turn reviews off. The **Pricing** tab on the actor page shows the current rates. Use **Max items** to cap the cost of any run.

#### Is it legal to scrape KREAM?

This actor collects only publicly available marketplace data. You are responsible for how you use it: follow KREAM's terms and the laws that apply to you, and get legal advice before any commercial redistribution. Prices and stock levels reflect the moment the run was made, not a live feed.

#### Can I get only new or changed prices on a schedule?

Yes. Schedule the actor from the **Schedules** tab and turn on **Incremental mode**. Each run then returns only new, updated and reappeared products, since a price, ask, bid or wish-count move is real signal on a resale marketplace, not noise, and unchanged products are not billed unless you turn on **Emit unchanged**.

#### Do the sort and filter fields work when I paste a search link?

Yes. `sort`, `quickDelivery`, `belowRetail`, `excludeSoldOut`, `category` and `gender` all apply in both search mode and URL mode: a pasted KREAM search URL is re-run through KREAM's search with them applied. The one exception is a pasted product URL, which always returns that single product in full, unfiltered.

#### How do I tell a blocked run from a search with no matches?

If KREAM keeps refusing requests, the run stops early and its status message reads `0 listings (BLOCKED)`, while a genuine empty search reads `0 listings (ZERO_RESULTS)`. Products collected before a block are kept. Switch the connection to Apify Residential and run it again.

#### Can I use it with AI agents or MCP?

Yes. Call it from any Apify integration or MCP client, and use the connector field to push results into Notion, Linear or Airtable.

### 🔗 Want more fashion data?

Pair this actor with these related scrapers from the same team:

<table>
<tr><td>👗 <a href="https://apify.com/abotapi/goat-sneaker-scraper"><b>GOAT Scraper</b></a><br>Scrape GOAT (goat.com), the sneaker and streetwear resale marketplace. Search or paste...</td><td>👗 <a href="https://apify.com/abotapi/stockx-market-data-scraper"><b>StockX Scraper</b></a><br>Scrape StockX market data by keyword, category or URL. Every row carries lowest ask...</td></tr>
<tr><td>👗 <a href="https://apify.com/abotapi/snkrdunk-com-scraper"><b>SNKRDUNK Scraper</b></a><br>Scrape SNKRDUNK (snkrdunk.com), Japan's sneaker and streetwear resale marketplace: JP and...</td><td>👗 <a href="https://apify.com/abotapi/klekt-com-scraper"><b>KLEKT Sneaker &amp; Apparel Resale Scraper</b></a><br>Scrape sneaker and streetwear listings from KLEKT (klekt.com). Browse the catalog with...</td></tr>
<tr><td>🏷️ <a href="https://apify.com/abotapi/curtsy-app-scraper"><b>Curtsy Fashion Resale Scraper</b></a><br>Scrape Curtsy, the US secondhand fashion marketplace: listings with brand, size, list vs...</td><td>👗 <a href="https://apify.com/abotapi/showpo-com-scraper"><b>Showpo Scraper</b></a><br>Scrape Showpo women's fashion by keyword, collection or URL. Extract product prices...</td></tr>
</table>

👉 [Browse all abotapi scrapers](https://apify.com/abotapi)

### 💬 Support

- 🐞 **Found a bug or a missing field?** Open a ticket on the [Issues tab](https://apify.com/abotapi/kream-scraper/issues/open). We usually reply within hours.
- 🛠️ **Need another site, extra fields or a private build?** Email <contact@abotapi.com>.
- ⭐ **Enjoying it?** A quick review on the actor page helps other users find it.

# Actor input Schema

## `mode` (type: `string`):

How to start the scrape. 'search' runs KREAM keyword searches. 'url' processes the KREAM URLs you paste (product URLs are fetched as full detail; search URLs are paged). Only where the keyword comes from differs: the sort and filter fields apply in BOTH search mode and URL mode, to every pasted KREAM search URL as well.

## `keywords` (type: `array`):

One or more keywords to search KREAM for (e.g. 'nike dunk', 'jordan 1', 'stussy'). Each keyword is scraped independently. Search mode only: in URL mode the keyword is read out of each pasted KREAM search URL instead, and this field is not used.

## `urls` (type: `array`):

Paste KREAM product URLs (https://kream.co.kr/products/<id>, with or without a size query or the www. / m. host), search URLs (https://kream.co.kr/search?keyword=..., Korean or percent-encoded keywords, plus optional category_id, sort and gender parameters) or brand pages (https://kream.co.kr/brands/<brand>). Product URLs return full detail; search and brand URLs page forward automatically. A sort, category_id or gender written in a pasted URL wins over the matching field below for that URL only; the sort and filter fields below are NOT ignored here and still apply to every search or brand URL. A pasted product URL is the one exception, since it returns that single product in full. A page=N (or cursor=N) in a search link starts at that page, and a link with page=N above 1 is not a full scan, so it never produces EXPIRED rows; shop_category_id and the size query on a product link are ignored with a warning. Other KREAM pages (for example the home page, exhibitions or the old category paths) are skipped with a warning in the log. Leaving this field untouched runs one example of each supported link type.

## `sort` (type: `string`):

Order KREAM returns results in. Applies in BOTH search mode and URL mode: the search request is rebuilt for a pasted KREAM search URL, so this sort is sent with it. A pasted product URL returns that single product, so ordering does not apply to it.

## `quickDelivery` (type: `boolean`):

Only return products with KREAM Quick Delivery (express) inventory available. Applies in BOTH search mode and URL mode: it is sent as a server-side parameter on the search request built for a pasted KREAM search URL too. A pasted product URL always returns that one product unfiltered.

## `belowRetail` (type: `boolean`):

Only return products whose lowest ask is below the brand's retail (original) price. Applies in BOTH search mode and URL mode: products found through a pasted KREAM search URL are filtered by it as well. A pasted product URL always returns that one product unfiltered.

## `excludeSoldOut` (type: `boolean`):

Drop products with no live lowest ask (nothing currently buyable). Applies in BOTH search mode and URL mode: products found through a pasted KREAM search URL are filtered by it as well. A pasted product URL always returns that one product unfiltered.

## `category` (type: `string`):

Optional KREAM category slug to narrow results (e.g. 'sneakers'). Leave empty for all categories. Applies in BOTH search mode and URL mode: it is sent as a server-side parameter on the search request built for a pasted KREAM search URL too. A pasted product URL always returns that one product unfiltered.

## `gender` (type: `string`):

Optional gender filter. Applies in BOTH search mode and URL mode: it is sent as a server-side parameter on the search request built for a pasted KREAM search URL too. A pasted product URL always returns that one product unfiltered.

## `fetchDetails` (type: `boolean`):

Visit each product's detail endpoint to add price history and per-size ask/bid inventory, and (unless Reviews per product is 0) the product's reviews. Slower and adds a small per-item charge. Most fields (style code, release date, retail, sizes, market prices) are already included without this.

## `maxReviewsPerProduct` (type: `integer`):

Only used when Fetch full details is on. How many of a product's reviews to nest on its row under reviews (rating, size, fit survey, date, reviewer, helpful count). Set 0 to skip reviews. Maximum 100 per product (20 reviews are served per request). Each block of up to 10 delivered reviews adds one detail-enrichment unit for that row (1-10 reviews = 1 unit, 11-20 = 2), on top of the detail page itself.

## `maxItems` (type: `integer`):

The single cap on this run: stop after collecting this many products (across all keywords/URLs). Set 0 for unlimited. Accepts up to 100000.

## `maxPages` (type: `integer`):

Safety bound on how many result pages to walk per keyword. Leave empty (0) for no page limit — the run stops at Max items, not here. Does not impose a separate cap below Max items.

## `proxy` (type: `object`):

Use Apify Residential proxy for reliable results. A country pin is optional.

## `resumeFromRunId` (type: `string`):

Paste a previous run ID or dataset ID to continue a large crawl of products without returning or charging for products already collected there. Use this after an interrupted or capped run. For recurring monitoring of the same search, use Incremental mode below instead.

## `incrementalMode` (type: `boolean`):

Turn this on for daily/weekly recurring monitoring of the same search. The first run returns all matching products as NEW. Later runs normally return only NEW, UPDATED, and REAPPEARED products. UPDATED compares every output field of the product (name, brand, retail/ask/bid/market prices, sales, wish/review/have counters, availability flags, sizes, images and, with Fetch full details, price history and recent sales/asks/bids) against the last run, and changedFields lists which ones moved; price/ask/bid/wish changes ARE reported, as they are the real signal on a resale marketplace. Five alias fields (productNameEn, productUrl, modelNumber, releasePrice and price) are not compared on their own because they mirror productName, url, styleCode, retailPrice and lowestAsk, which are compared; nothing else is excluded by default. Use 'Ignore fields when detecting changes' to exclude a noisy field (it stays in the output). Turn on "Emit unchanged" or "Emit expired" only when you also want those products returned (and billed). State is kept separately per search/URL/sort/filter setup; use State key to name or deliberately share a monitoring campaign. To continue one specific interrupted run instead, use Resume from a previous run above.

## `stateKey` (type: `string`):

Optional. Name this monitoring campaign to keep its state stable, or to deliberately share state across differently-configured runs. Leave empty to let the actor derive a key automatically from the keyword/URL, sort and filter settings — different searches then never mix state with each other.

## `emitUnchanged` (type: `boolean`):

Off by default. Turn on to also return products that have not changed since the last run, marked UNCHANGED. This returns — and bills — extra rows you already have, so leave it off unless you specifically want the full snapshot every run.

## `emitExpired` (type: `boolean`):

Off by default. Turn on to also return products that were present in a previous run but are no longer found, marked EXPIRED. Only produced once a run has fully scanned the tracked search — not when Max items capped it, Resume was used, or the run was blocked. This returns — and bills — extra synthetic rows, so leave it off unless you need expiry tracking.

## `ignoreFieldsForChanges` (type: `array`):

Optional. Field names to exclude from UPDATED change detection and from changedFields; the field stays in the output. Use a top-level field name (for example wishCount) or a dotted path for a nested field (for example parent.child; lists are searched element by element). Changing this list never causes a one-time wave of UPDATED rows, because stored products are re-compared using the current list.

## `mcpConnectors` (type: `array`):

Optionally send results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize one under Apify → Settings → API & Integrations, then select it here. Notion gets a rich page-per-item export; other connectors get a best-effort write/digest. Leave empty to skip; never changes the dataset output. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com).

## `notionParentPageUrl` (type: `string`):

URL (or id) of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on items written to each connector per run. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "search",
  "keywords": [
    "nike"
  ],
  "urls": [
    "https://kream.co.kr/search?keyword=nike",
    "https://kream.co.kr/search?keyword=%EB%82%98%EC%9D%B4%ED%82%A4",
    "https://kream.co.kr/search?keyword=nike&category_id=1",
    "https://kream.co.kr/search?keyword=nike&sort=date_released&tab=products",
    "https://kream.co.kr/products/23879",
    "https://www.kream.co.kr/search?keyword=jordan&tab=products",
    "https://kream.co.kr/brands/nike"
  ],
  "sort": "popularity",
  "quickDelivery": false,
  "belowRetail": false,
  "excludeSoldOut": false,
  "gender": "",
  "fetchDetails": false,
  "maxReviewsPerProduct": 20,
  "maxItems": 20,
  "maxPages": 0,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "ignoreFieldsForChanges": [],
  "maxNotifyListings": 50
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `detail` (type: `string`):

No description

## `changes` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mode": "search",
    "keywords": [
        "nike"
    ],
    "urls": [
        "https://kream.co.kr/search?keyword=nike",
        "https://kream.co.kr/search?keyword=%EB%82%98%EC%9D%B4%ED%82%A4",
        "https://kream.co.kr/search?keyword=nike&category_id=1",
        "https://kream.co.kr/search?keyword=nike&sort=date_released&tab=products",
        "https://kream.co.kr/products/23879",
        "https://www.kream.co.kr/search?keyword=jordan&tab=products",
        "https://kream.co.kr/brands/nike"
    ],
    "maxReviewsPerProduct": 20,
    "maxItems": 20,
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    },
    "incrementalMode": false,
    "emitUnchanged": false,
    "emitExpired": false,
    "ignoreFieldsForChanges": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/kream-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "mode": "search",
    "keywords": ["nike"],
    "urls": [
        "https://kream.co.kr/search?keyword=nike",
        "https://kream.co.kr/search?keyword=%EB%82%98%EC%9D%B4%ED%82%A4",
        "https://kream.co.kr/search?keyword=nike&category_id=1",
        "https://kream.co.kr/search?keyword=nike&sort=date_released&tab=products",
        "https://kream.co.kr/products/23879",
        "https://www.kream.co.kr/search?keyword=jordan&tab=products",
        "https://kream.co.kr/brands/nike",
    ],
    "maxReviewsPerProduct": 20,
    "maxItems": 20,
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
    "incrementalMode": False,
    "emitUnchanged": False,
    "emitExpired": False,
    "ignoreFieldsForChanges": [],
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/kream-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "search",
  "keywords": [
    "nike"
  ],
  "urls": [
    "https://kream.co.kr/search?keyword=nike",
    "https://kream.co.kr/search?keyword=%EB%82%98%EC%9D%B4%ED%82%A4",
    "https://kream.co.kr/search?keyword=nike&category_id=1",
    "https://kream.co.kr/search?keyword=nike&sort=date_released&tab=products",
    "https://kream.co.kr/products/23879",
    "https://www.kream.co.kr/search?keyword=jordan&tab=products",
    "https://kream.co.kr/brands/nike"
  ],
  "maxReviewsPerProduct": 20,
  "maxItems": 20,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "ignoreFieldsForChanges": []
}' |
apify call abotapi/kream-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,abotapi/kream-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/xb9yaUWSxK993aaa6/builds/IOCaDZkih82bvzULw/openapi.json