# Coupang KR $1.5💰 URL Keyword and Review Scraper (`abotapi/coupang-scraper`) Actor

Pull product listings from coupang.com via query, category, or URL. Returns 20+ structured fields including title, brand, price, discount, currency, rating, review count, images, product URL, delivery flags, availability, full description, and image gallery.

- **URL**: https://apify.com/abotapi/coupang-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Categories:** E-commerce, Developer tools, Automation
- **Stats:** 268 total users, 55 monthly users, 94.7% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.50 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Coupang Korea Product Scraper

Pull product listings from Coupang Korea by query, by category, or by direct URL. Returns 20+ structured fields per item: title, brand, price (current and original), discount %, on-special flag, savings amount, currency, rating, review count, image URL, product URL, Rocket Delivery flag, Tomorrow Delivery flag, availability, full description, and image gallery.

### Why this scraper

- 20+ fields per item, including price (current and original), discount %, on-special flag, savings amount, average rating, review count, Rocket / Tomorrow / Fresh / Global delivery badges, and full image gallery.
- Three run modes: search (query + filters), url (multi-URL walk, and the price / Rocket / rating filters apply there too), and reviews (customer reviews by product ID).
- Forward-walking pagination with per-search budget cap so multiple queries each get fair coverage.
- Korean locale and UTC-9 timezone baked into the worker so price formatting and delivery promises match what Korean shoppers see.
- Network discipline: fonts, media, and ad / analytics domains are blocked at the worker level. Bandwidth and wall time per page are noticeably lower than a default run.

### Data you get

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

| Field | Example |
|---|---|
| `productId` | `0000000001` |
| `title` | `Sample Product Title` |
| `brand` | `Sample Brand` |
| `url` | `https://www.coupang.com/vp/products/0000000001?itemId=0&vendorItemId=0` |
| `image` | `https://thumbnail.coupangcdn.com/thumbnails/remote/230x230ex/sample.jpg` |
| `images` | `["https://thumbnail.coupangcdn.com/thumbnails/remote/492x492ex/sample-1.jpg", "...sample-2.jpg"]` |
| `price` | `3490` |
| `originalPrice` | `5500` |
| `discountPercent` | `36` |
| `isOnSpecial` | `true` |
| `savingsAmount` | `2010` |
| `unitPrice` | `(1개당 1,745원)` |
| `currency` | `KRW` |
| `rating` | `4.7` |
| `reviewCount` | `0` |
| `rocketDelivery` | `true` |
| `rocketFresh` | `false` |
| `rocketGlobal` | `false` |
| `tomorrowDelivery` | `true` |
| `freeShipping` | `true` |
| `shippingCost` | `0` |
| `availability` | `InStock` |
| `deliveryInfo` | `내일(목) 도착 보장` |
| `categoryId` | `178155` |
| `categoryPath` | `가전디지털 > 컴퓨터 > 노트북` on a category-browse URL, or on any mode with `fetchDetails = true` (read from the product's own breadcrumb). `null` on a keyword search result left at its default (`fetchDetails = false`): Coupang's search-results page carries no category breadcrumb of its own, only category-browse pages and product pages do |
| `description` | `Full product description appears here when fetchDetails = true.` |
| `query` | `노트북` |
| `scrapedAt` | `2026-01-01T00:00:00.000Z` |

### Specials, was-price & discount

Every listing carries `price` (what you pay), `originalPrice` (the strike-through
was-price, when Coupang shows one), `discountPercent`, `isOnSpecial`, and
`savingsAmount` (`originalPrice - price`). These come straight off the search/
category card and, when `fetchDetails = true`, are only ever **upgraded** by
the product detail page, never overwritten: a detail page may lower `price`
further (a genuinely cheaper price on the PDP) but can never raise it above the
card's sale price or null out a real card-derived discount. A non-discounted
item always reports `originalPrice: null`, `isOnSpecial: false`,
`savingsAmount: null`, never fabricated.

**No dedicated "specials category" input.** We investigated Coupang's Gold Box
(골드박스) deals hub (the site's own daily-deals surface) using the actor's
existing browsing session. It renders as a client-side **banner/ad
widget system** (`page-type="OMS"`), not a product grid: the fetched HTML
carries zero `/vp/products/` links and zero price data, only ad-tracking
pixels, and the page is not consistently reachable (403 on a same-session
repeat navigation). It is structurally incompatible with the `ul#product-list`
extraction this actor is built around, and unstable to boot. No other stable,
resolvable "on-sale" facet exists in Coupang's `/np/search` or
`/np/categories` URL grammar either (only `sorter`, `component`, `minPrice`/
`maxPrice`, and `rocketAll`, all already supported). Rather than fabricate a
`specialsCategory` input pointing at markup that can't be reliably parsed, this
actor surfaces the was-price/discount fields on **every** listing returned by
search, category browse, or URL mode, including a keyword search for
`특가`/`골드박스`, which is the honest way to reach discounted items today.

### How to use

Search by Korean keyword:

```json
{
  "mode": "search",
  "queries": ["노트북"],
  "maxPages": 3,
  "maxListings": 60,
  "proxy": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "KR" }
}
```

Search by English keyword with filters:

```json
{
  "mode": "search",
  "queries": ["wireless mouse"],
  "minPrice": 10000,
  "maxPrice": 50000,
  "rocketOnly": true,
  "minRating": 4,
  "sortBy": "salePriceAsc",
  "maxPages": 5,
  "maxListings": 100,
  "fetchDetails": true,
  "proxy": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "KR" }
}
```

Walk multiple categories or saved searches. The price / Rocket / rating filters apply here too, so a
pasted category or search URL can be narrowed the same way a keyword search can:

```json
{
  "mode": "url",
  "urls": [
    "https://www.coupang.com/np/categories/178255",
    "https://www.coupang.com/np/categories/178255?page=2"
  ],
  "minPrice": 10000,
  "rocketOnly": true,
  "minRating": 4,
  "maxPages": 2,
  "maxListings": 120
}
```

Scrape a specific product detail page:

```json
{
  "mode": "url",
  "urls": ["https://www.coupang.com/vp/products/0000000001?itemId=00000000&vendorItemId=00000000"],
  "fetchDetails": true
}
```

Pull customer reviews for one or more products (one record per review):

```json
{
  "mode": "reviews",
  "productIds": ["0000000002", "0000000001"],
  "maxReviewsPerProduct": 50,
  "reviewSortBy": "DATE_DESC",
  "proxy": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "KR" }
}
```

Reviews mode returns 17 fields per review including title, content, rating, date, helpful counts, photos, videos, vendor name, the variant the reviewer bought, and Coupang's structured survey answers (사용 목적 / 무게 / 성능 buckets). Pull only 1-star reviews for negative-feedback analysis:

```json
{
  "mode": "reviews",
  "productIds": ["0000000002"],
  "reviewRatingFilter": 1,
  "maxReviewsPerProduct": 50
}
```

### Resume vs Incremental mode

Two different tools for two different jobs — pick the one that matches what you're actually doing:

**Resume (`resumeFromRunId`)** continues ONE specific interrupted run. Paste a previous run ID or
dataset ID and this run skips products (or reviews, in Reviews mode) already collected there,
appending only new ones — use this after a timeout/crash, or to keep extending one large walk-all
pull across several runs without re-scraping (and re-billing) what you already have.

```json
{ "mode": "url", "urls": ["https://www.coupang.com/np/categories/178255"], "maxPages": 5, "resumeFromRunId": "PREVIOUS_RUN_ID" }
```

**Incremental mode (`incrementalMode`)** is for scheduling this actor daily/weekly against the SAME
search, category, or URL list and getting only what changed. The actor remembers its own state
(keyed by mode + queries/category/URLs/filters, or your own `stateKey`) — no run ID to paste. The
first run returns everything as `NEW`; later runs return only `NEW`, `UPDATED`, and `REAPPEARED` by
default. Search and URL mode only — Reviews mode has no persistent per-review baseline.

```json
{ "mode": "url", "urls": ["https://www.coupang.com/np/categories/178255"], "incrementalMode": true }
```

Every row gets a `changeType`: `NEW` (first time seen), `UPDATED` (content changed — check
`changedFields` for exactly which keys), `UNCHANGED` (identical to last run — only returned when
`emitUnchanged` is on), `REAPPEARED` (was gone, now back), or `EXPIRED` (tracked previously, not
found this run — only returned when `emitExpired` is on, and only after a run that scanned the full
tracked search with no cap hit and no resume). `emitUnchanged` and `emitExpired` are both off by
default because they return — and bill — extra rows; turn them on only when you specifically need
that signal. `firstSeenAt`/`lastSeenAt` track when a product was first and most recently observed.

Both features can combine: `incrementalMode` + `resumeFromRunId` bootstraps a fresh incremental
baseline from a prior resume-style pull's dataset (so nothing looks `NEW` again tomorrow) — but only
on a genuinely first run for that state key; if incremental state already exists, the run stops
rather than silently mixing two different baselines.

When `fetchDetails` is on, a suppressed `UNCHANGED` product may still have had its detail page
fetched (needed to compute the fingerprint), but it is never pushed and never billed the detail
enrichment surcharge — only products that actually reach the dataset are charged for enrichment.

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` for query + filters, `url` for direct URL walking, `reviews` for customer reviews by product ID |
| `queries` | array | `["노트북"]` | (Search mode) One or more Korean or English search terms |
| `categoryId` | integer | (none) | (Search mode) Optional category id to narrow the search. In URL mode the category comes from the pasted URL itself |
| `minPrice` | integer | (none) | (Search + URL modes) Minimum item price in KRW. Sent to coupang.com in search mode and re-checked in the actor; applied in the actor in URL mode |
| `maxPrice` | integer | (none) | (Search + URL modes) Maximum item price in KRW. Sent to coupang.com in search mode and re-checked in the actor; applied in the actor in URL mode |
| `rocketOnly` | boolean | `false` | (Search + URL modes) Keep only items eligible for the Rocket Delivery service. Sent to coupang.com in search mode and re-checked in the actor; applied in the actor in URL mode |
| `minRating` | integer | (none) | (Search + URL modes) Minimum average rating, 1 to 5. Never sent to coupang.com, so it is always applied in the actor, in both modes |
| `sortBy` | string | `scoreDesc` | (Search mode) One of `scoreDesc`, `salePriceAsc`, `salePriceDesc`, `latest`, `saleCountDesc`. A pasted URL keeps its own sort order |
| `urls` | array | (none) | (URL mode) One or more `coupang.com/np/search`, `/np/categories/...`, or `/vp/products/...` URLs. The four filters above still apply to the listings walked from a search or category URL; only a pasted `/vp/products/` URL is returned unfiltered |
| `productIds` | array | (none) | (Reviews mode) One or more product IDs or product URLs |
| `maxReviewsPerProduct` | integer | `50` | (Reviews mode) Reviews per product to fetch via the paginated API |
| `reviewSortBy` | string | `ORDER_SCORE_ASC` | (Reviews mode) `ORDER_SCORE_ASC` (Best) or `DATE_DESC` (Newest) |
| `reviewRatingFilter` | integer | (none) | (Reviews mode) Only return reviews with this exact star rating (1 to 5) |
| `maxPages` | integer | `3` | Pages to walk per query / URL (60 items per page) |
| `maxListings` | integer | `0` | Stop after this many items (0 = unlimited) |
| `fetchDetails` | boolean | `false` | Visit each product page for brand, full description, image gallery, shipping |
| `proxy` | object | Apify Residential KR | Proxy configuration |
| `resumeFromRunId` | string | (none) | Continue ONE specific interrupted run — see "Resume vs Incremental mode" above |
| `incrementalMode` | boolean | `false` | Cross-run change detection for recurring/scheduled runs (Search/URL mode only) — adds `changeType` (NEW/UPDATED/UNCHANGED/REAPPEARED/EXPIRED) to every row. See above. |
| `stateKey` | string | (auto) | Name a monitoring campaign, or leave empty to derive one automatically from mode + search/category/URL/filter settings |
| `emitUnchanged` | boolean | `false` | Also return UNCHANGED products — returns (and bills) extra rows |
| `emitExpired` | boolean | `false` | Also return products no longer found (EXPIRED) — only after a complete, uncapped, non-resumed scan; returns (and bills) extra rows |

### 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 record — not the full JSON. Each item becomes one entry with a **title** and its key fields flattened to plain text. 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.

### Output example

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

```json
{
  "productId": "0000000001",
  "title": "Sample Product Title",
  "brand": "Sample Brand",
  "url": "https://www.coupang.com/vp/products/0000000001?itemId=0&vendorItemId=0",
  "image": "https://thumbnail.coupangcdn.com/thumbnails/remote/230x230ex/sample.jpg",
  "images": [
    "https://thumbnail.coupangcdn.com/thumbnails/remote/492x492ex/sample-1.jpg",
    "https://thumbnail.coupangcdn.com/thumbnails/remote/492x492ex/sample-2.jpg"
  ],
  "price": 3490,
  "originalPrice": 5500,
  "discountPercent": 36,
  "isOnSpecial": true,
  "savingsAmount": 2010,
  "unitPrice": "(1개당 1,745원)",
  "currency": "KRW",
  "rating": 4.7,
  "reviewCount": 0,
  "rocketDelivery": true,
  "rocketFresh": false,
  "rocketGlobal": false,
  "tomorrowDelivery": true,
  "freeShipping": true,
  "shippingCost": 0,
  "availability": "InStock",
  "deliveryInfo": "내일(목) 도착 보장",
  "categoryId": "178155",
  "categoryPath": "가전디지털 > 컴퓨터 > 노트북",
  "description": "Full seller description text appears here when fetchDetails = true.",
  "query": "노트북",
  "scrapedAt": "2026-01-01T00:00:00.000Z"
}
```

### Plan requirement

Coupang serves Korean shoppers. The upstream edge filter accepts very little non-Korean traffic, so the actor needs **Apify Residential proxy with country `KR`**. This is included in the Apify Starter plan and above.

If you are on the free plan and pick a non-residential proxy, the actor falls back to a small datacenter pool. Throughput is much lower and many pages will not return data; for production runs the upgrade is essential.

Default memory is 1024 MB. Increase to 2048 MB for runs that walk more than 200 pages so the worker has headroom across the full session.

### Verification note (2026-08-31)

URL and search modes re-verified against the live site on 2026-08-31 using the actor's own KR-residential browser session: the keyword search for laptops returned 54 items per page, the Rocket delivery facet narrowed it to 53 and a specific accessory keyword to 46, and a pasted product detail URL parsed 16 populated fields (title, price). Fresh exit rotation handled intermittent edge refusals within the existing attempt cap. No defect found; version bumped so the Store listing carries a freshly dated, re-verified build.

# Actor input Schema

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

Pick how to start. 'search' uses query + filters below. 'url' walks one or more category / search URLs. 'reviews' returns customer reviews for a list of product IDs (one record per review, ~10 reviews per product).

## `queries` (type: `array`):

One or more Korean or English search terms (e.g. '노트북', 'laptop'). Only used when mode = search.

## `categoryId` (type: `integer`):

Optional: narrow the search to a Coupang category id (the number after /np/categories/ in a category URL). Leave empty for all categories. Only used when mode = search; in URL mode the category comes from the pasted URL itself, and in Reviews mode this field is ignored.

## `sortBy` (type: `string`):

Sort the search results. Only used when mode = search, where it is sent to coupang.com as the sort parameter; a pasted URL keeps whatever sort order it already carries, and Reviews mode has its own separate sort field below.

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

One or more https://www.coupang.com/np/search?q=, /np/categories/<id>, or /vp/products/<id> URLs. Multi-URL supported. Pagination starts at the page in the URL and walks forward. The Filters section below (min price, max price, Rocket Delivery only, minimum rating) DOES apply to the listings walked from a pasted search or category URL; only a pasted /vp/products/ product URL is returned unfiltered, because that URL names one specific product. Search-only fields (search queries, category ID, sort order) are ignored here.

## `productIds` (type: `array`):

One or more Coupang product IDs (the number after /vp/products/ in a product URL) OR full product URLs. Output is one record per review.

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

How many reviews to fetch per product. The actor pages through Coupang's review API to reach this number. Most popular products have 1000+ reviews available. Default 50.

## `reviewSortBy` (type: `string`):

How to order the reviews returned. 'Best' is Coupang's recommended ranking (mixes rating and helpfulness); 'Newest' returns most recent first.

## `reviewRatingFilter` (type: `integer`):

Optional. When set, only return reviews with this exact star rating (1, 2, 3, 4, or 5). Useful for analysing low-rated reviews or pulling only top reviews.

## `minPrice` (type: `integer`):

Optional: only return items with price >= this value. Leave empty for no lower bound. Applies in BOTH search mode and URL mode. In search mode the value is also sent to coupang.com as a search parameter, so results are narrowed on the site first and then re-checked here; in URL mode the pasted URL is walked exactly as given and the check runs here, on every listing found. Has no effect in Reviews mode, and a pasted /vp/products/ product URL is returned unfiltered.

## `maxPrice` (type: `integer`):

Optional: only return items with price <= this value. Leave empty for no upper bound. Applies in BOTH search mode and URL mode. In search mode the value is also sent to coupang.com as a search parameter, so results are narrowed on the site first and then re-checked here; in URL mode the pasted URL is walked exactly as given and the check runs here, on every listing found. Has no effect in Reviews mode, and a pasted /vp/products/ product URL is returned unfiltered.

## `rocketOnly` (type: `boolean`):

Keep only items eligible for the next-day Rocket Delivery service. Applies in BOTH search mode and URL mode. In search mode the value is also sent to coupang.com as a search parameter, so results are narrowed on the site first and then re-checked here; in URL mode the pasted URL is walked exactly as given and the check runs here, on every listing found. Has no effect in Reviews mode, and a pasted /vp/products/ product URL is returned unfiltered.

## `minRating` (type: `integer`):

Optional: only keep items whose average rating is >= this value (1 to 5). Applies in BOTH search mode and URL mode. Unlike the price and Rocket Delivery filters, this one is never sent to coupang.com (its rating parameter triggers stricter blocking), so in both modes the check always runs here, on every listing found. Has no effect in Reviews mode, and a pasted /vp/products/ product URL is returned unfiltered; to filter reviews by star rating use the Reviews mode rating field above.

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

How many pages of results to walk per query or URL. Each page returns up to 60 items.

## `maxListings` (type: `integer`):

Stop after this many items in total across all queries / URLs. 0 = unlimited.

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

Off (default, recommended): each item gets 15 fields (productId, vendorItemId, itemId, title, price, originalPrice, discountPercent, currency, rating, reviewCount, image, url, isSponsored, rocketDelivery, tomorrowDelivery). Fast and cheap. On: also visits each product page to add brand, full image gallery, description, shipping details, availability, category path, and a spec key-value map (~11 entries). Each detail page adds one navigation, so total cost is roughly 5x the lean run.

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

Pick the proxy. Korean or Japanese residential is strongly recommended; the upstream edge filter rejects most other exits.

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

Optionally send the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize a connector once under Apify → Settings → Integrations, then select it here. The connector receives a condensed, human-readable summary per item (title + key fields), not the full JSON — the complete record stays in the dataset. Leave empty to skip. 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.

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

Paste a previous run ID or dataset ID to continue a large pull without returning or charging for products already collected there. Use this after an interrupted run, or to keep extending one walk-all pull across separate runs. For recurring daily monitoring of the same search, use Incremental mode below instead.

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

Turn this on for daily or recurring monitoring of Search or URL mode. The first run returns all matching products as NEW. Later runs normally return only NEW, UPDATED, and REAPPEARED products. Turn on "Emit unchanged" or "Emit expired" only when you also want those products returned (and billed). State is kept separately per mode + queries/category/URLs/filters configuration; use State key when you want to name or deliberately share a monitoring campaign. Has no effect in Reviews mode. 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 mode + search/category/URL/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 listings capped it or when Resume was used. This returns — and bills — extra synthetic rows, so leave it off unless you need expiry tracking.

## Actor input object example

```json
{
  "mode": "search",
  "queries": [
    "노트북"
  ],
  "sortBy": "scoreDesc",
  "urls": [
    "https://www.coupang.com/np/categories/178255"
  ],
  "productIds": [
    "8499380264"
  ],
  "maxReviewsPerProduct": 50,
  "reviewSortBy": "ORDER_SCORE_ASC",
  "rocketOnly": false,
  "maxPages": 1,
  "maxListings": 0,
  "fetchDetails": false,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "KR"
  },
  "maxNotifyListings": 50,
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false
}
```

# Actor output Schema

## `overview` (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",
    "queries": [
        "노트북"
    ],
    "urls": [
        "https://www.coupang.com/np/categories/178255"
    ],
    "productIds": [
        "8499380264"
    ],
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "KR"
    },
    "incrementalMode": false,
    "emitUnchanged": false,
    "emitExpired": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/coupang-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",
    "queries": ["노트북"],
    "urls": ["https://www.coupang.com/np/categories/178255"],
    "productIds": ["8499380264"],
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "KR",
    },
    "incrementalMode": False,
    "emitUnchanged": False,
    "emitExpired": False,
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/coupang-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",
  "queries": [
    "노트북"
  ],
  "urls": [
    "https://www.coupang.com/np/categories/178255"
  ],
  "productIds": [
    "8499380264"
  ],
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "KR"
  },
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false
}' |
apify call abotapi/coupang-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,abotapi/coupang-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/foGTFE4fecZH35VGe/builds/NHE7ygOSIGgjouYsx/openapi.json