# Coupang Scraper — Products, Prices, Ratings by Keyword (`memo23/coupang-scraper`) Actor

Scrape Coupang (쿠팡) search results — product name, price (KRW), discount, rating, review count, image and URL. Search by any Korean or English keyword, paginated. Clean JSON/CSV, no login.

- **URL**: https://apify.com/memo23/coupang-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** E-commerce, AI, Agents
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 products

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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 Scraper

Scrape **Coupang** (쿠팡, Korea's largest online marketplace) search results at scale — product name, price in KRW, rating, review count, image, and URL — for any keyword. Pure HTTP against Coupang's own search data: no browser, no Playwright, fast and cheap to run.

![How Coupang Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-coupang.png)

#### ✨ Why use this scraper?

- **Full search coverage** — every product on a Coupang search results page (~58 per page), auto-paginated up to your item cap.
- **Korean or English keywords** — search `노트북`, `laptop`, `에어팟`, `airpods`; whatever you'd type on coupang.com.
- **Real KRW prices, ratings & reviews** — pulled from Coupang's own structured product data, so they match the site exactly.
- **No browser overhead** — the actor reads Coupang's server-rendered product feed directly. Runs finish in seconds.
- **Built-in Korean residential proxies** — Coupang blocks datacenter and non-KR traffic; the actor rotates a fresh Korean residential IP per request automatically, with retry-on-block. No proxy setup needed.
- **Clean, predictable output** — one dataset row per product, no padding rows. JSON or CSV.

#### 🎯 Use cases

- **Price monitoring & repricing** — track competitor prices across Coupang for your catalog.
- **Market & assortment research** — see what's selling, how it's rated, and how it's ranked for any category keyword.
- **Brand & seller monitoring** — follow how your products (and knock-offs) appear in Coupang search.
- **Review-volume signals** — review counts and ratings are a strong proxy for demand and product maturity.
- **Rocket-delivery analysis** — spot which listings carry Coupang's Rocket (로켓배송) badge.

#### 📥 Supported inputs

| Input | What it does |
|---|---|
| `searchQueries` | Keywords to search (Korean or English) — each is paginated up to `maxItems` |
| `startUrls` | Direct Coupang search URLs (`/np/search?q=…`) |
| `maxItems` | Hard cap on total product rows (billing cap) |
| `proxy` | Optional custom proxy override (defaults to built-in Korean residential) |

#### 🔄 How it works

1. Every keyword becomes a Coupang search URL (`/np/search?q=<query>&channel=user`).
2. The actor routes the request through a Korean residential IP and fetches the server-rendered search page — no browser.
3. It parses Coupang's embedded structured product list (schema.org JSON-LD), then merges in the Rocket/ad/rank badges from the page markup.
4. Each product is pushed as one clean row. Pages advance automatically until your item cap or the results run out.
5. If Coupang returns an anti-bot block, the request retries on a fresh Korean IP.

#### ⚙️ Input parameters

```json
{
    "searchQueries": ["노트북", "airpods"],
    "maxItems": 200
}
````

#### 📊 Output overview

One row per **search-result product**. Every row carries the query it came from (`sourceQuery`) and its position (`rank`) so results are self-describing in CSV exports.

#### 📦 Output sample

```json
{
    "productId": "9425678602",
    "itemId": "28018355098",
    "vendorItemId": "94975619139",
    "title": "Apple 2025 에어팟 프로 3 USB-C 블루투스 이어폰",
    "productUrl": "https://www.coupang.com/vp/products/9425678602?itemId=28018355098&vendorItemId=94975619139",
    "image": "https://thumbnail.coupangcdn.com/thumbnails/remote/320x320ex/image/…",
    "price": 332100,
    "currency": "KRW",
    "rating": 5,
    "reviewCount": 15278,
    "availability": "InStock",
    "isRocket": true,
    "isAd": false,
    "rank": 1,
    "sourceQuery": "airpods",
    "scrapedAt": "2026-07-22T08:25:00.000Z"
}
```

#### 🗂 Key output fields

| Field | Meaning |
|---|---|
| `productId` / `itemId` / `vendorItemId` | Coupang's three product identifiers (from the product URL) |
| `title` | Product name as shown on Coupang (Korean) |
| `price` / `currency` | Current selling price, integer KRW |
| `rating` / `reviewCount` | Average star rating and number of reviews |
| `availability` | Stock status (`InStock`, etc.) |
| `isRocket` | Carries the Rocket-delivery (로켓배송) badge |
| `isAd` | Sponsored / ad placement in the results |
| `rank` | 1-based position within the search results |
| `sourceQuery` | The keyword this product was found under |
| `image` / `productUrl` | Thumbnail URL and canonical product-page URL |

#### ❓ FAQ

**Does this scrape individual product detail pages?**
No. Coupang hard-blocks its product-detail pages (`/vp/products/…`) for non-browser clients (Akamai). This actor works from the **search/listing** feed, which already carries name, price, rating, review count, image, and URL for every result. If you paste a product URL, its id is searched as a keyword instead.

**Are prices really in KRW?**
Yes — the actor requests Coupang from a Korean IP, so prices and availability are exactly what a Korean shopper sees, in Korean won.

**Why do I need proxies? Can I turn them off?**
Coupang blocks datacenter and non-Korean traffic aggressively. The actor ships with built-in Korean residential proxies and rotates a fresh IP per request. You can supply your own proxy via the `proxy` input, but it must be Korean residential to work.

**How many products per search?**
About 58 per results page; the actor paginates automatically until it reaches your `maxItems` cap or runs out of results.

**Can I search in English?**
Yes — Coupang search handles both English and Korean terms. Korean keywords generally return more complete results.

#### 💬 Support

- Found a bug or need a field added? Open an issue on the actor's **Issues** tab in the Apify Console — issues are answered within a day.
- Custom requirements (specific categories, bigger volumes, private deployment)? Message via the Apify contact form.

#### 🛠 Additional services

- **Scheduling & monitoring** — run the actor on a cron schedule from the Apify Console and export new rows to a webhook, database, or Google Sheets.
- **Custom scrapers** — need another marketplace scraped to the same standard? Get in touch via the profile below.

#### 🔎 Explore more scrapers

If this Coupang Scraper was useful, see other scrapers and actors at [memo23's Apify profile](https://apify.com/memo23) — covering e-commerce, social media, real estate, job boards, and more.

#### 🤖 For AI Agents & LLM Apps

This actor is agent-friendly: deterministic JSON output, one self-describing row per product, and a tiny input schema. Call it from LLM tool-use / MCP setups to give your agent live Korean-market pricing and demand signals — e.g. "what do AirPods cost on Coupang and how well are they rated?" maps to one run with `searchQueries: ["airpods"]`. Use `maxItems` to bound cost per call.

### ⚠️ Disclaimer

This actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Coupang Corp. It retrieves only publicly available data that Coupang serves to any visitor without signing in. "Coupang" and "쿠팡" are trademarks of Coupang Corp. You are responsible for how you use the data, including compliance with applicable laws and Coupang's terms of service.

### SEO Keywords

coupang scraper, coupang api, scrape coupang, coupang product scraper, coupang price scraper, korean ecommerce scraper, coupang search scraper, 쿠팡 스크래퍼, coupang data export, coupang price monitoring, coupang product data, korean marketplace scraper, coupang listings scraper, coupang json, coupang csv, coupang competitor pricing, coupang rating scraper, coupang review count, coupang no login

# Actor input Schema

## `searchQueries` (type: `array`):

Keywords to search on Coupang (Korean or English), e.g. `노트북`, `laptop`, `airpods`. Each is paginated up to Max items.

## `startUrls` (type: `array`):

Direct Coupang search URLs (e.g. `https://www.coupang.com/np/search?q=laptop`). A pasted product URL is accepted but, because product pages are blocked, its id is searched as a keyword instead.

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

Hard cap on the number of product rows produced across all searches (billing cap). ~58 products per search page.

## `maxConcurrency` (type: `integer`):

Reserved for future parallelism. Coupang is fetched sequentially per search to stay under Akamai's radar.

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

Custom proxy override. By default the actor routes through built-in Korean residential proxies with per-request IP rotation — you normally don't need to change this. Datacenter proxies will be blocked.

## Actor input object example

```json
{
  "searchQueries": [
    "노트북"
  ],
  "startUrls": [],
  "maxItems": 1000,
  "maxConcurrency": 8
}
```

# 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 = {
    "searchQueries": [
        "노트북"
    ],
    "startUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/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 = {
    "searchQueries": ["노트북"],
    "startUrls": [],
}

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

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

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

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "노트북"
  ],
  "startUrls": []
}' |
apify call memo23/coupang-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=memo23/coupang-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Coupang Scraper — Products, Prices, Ratings by Keyword",
        "description": "Scrape Coupang (쿠팡) search results — product name, price (KRW), discount, rating, review count, image and URL. Search by any Korean or English keyword, paginated. Clean JSON/CSV, no login.",
        "version": "0.0",
        "x-build-id": "50RYkkTESm1T6VZ8X"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~coupang-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-coupang-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/memo23~coupang-scraper/runs": {
            "post": {
                "operationId": "runs-sync-memo23-coupang-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/memo23~coupang-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-coupang-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchQueries": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Keywords to search on Coupang (Korean or English), e.g. `노트북`, `laptop`, `airpods`. Each is paginated up to Max items.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Coupang search URLs",
                        "type": "array",
                        "description": "Direct Coupang search URLs (e.g. `https://www.coupang.com/np/search?q=laptop`). A pasted product URL is accepted but, because product pages are blocked, its id is searched as a keyword instead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "type": "integer",
                        "description": "Hard cap on the number of product rows produced across all searches (billing cap). ~58 products per search page.",
                        "default": 1000
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "type": "integer",
                        "description": "Reserved for future parallelism. Coupang is fetched sequentially per search to stay under Akamai's radar.",
                        "default": 8
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Custom proxy override. By default the actor routes through built-in Korean residential proxies with per-request IP rotation — you normally don't need to change this. Datacenter proxies will be blocked."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```