# Coupang Eats Scraper (`amit123/coupang-eats-scraper`) Actor

Extract restaurants, menus, prices, ratings, and delivery info from **Coupang Eats (쿠팡이츠)** — South Korea's #2 food delivery platform and one half of a fast-tightening duopoly that now controls ~88% of the Korean delivery market.

- **URL**: https://apify.com/amit123/coupang-eats-scraper.md
- **Developed by:** [Amit](https://apify.com/amit123) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Features:** Full permissions
- **Stats:** 15 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 results

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/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

## 🍱 Coupang Eats Crawler

Extract restaurants, menus, prices, ratings, and delivery info from **Coupang Eats (쿠팡이츠)** — South Korea's #2 food delivery platform and one half of a fast-tightening duopoly that now controls ~88% of the Korean delivery market.

***

### 🌏 What is Coupang Eats?

Coupang Eats is the food-delivery arm of **Coupang**, Korea's largest e-commerce company (the "Amazon of Korea", NYSE-listed CPNG). Coupang Eats launched in 2019 as a third-place challenger to Baemin (Baedal Minjok) and Yogiyo. As of May 2026 it has overtaken Yogiyo and become the clear #2:

| Platform | Weekly Active Users (May 2026) | Market position |
|---|---|---|
| **Baemin** (Baedal Minjok) | ~12M | #1 |
| **Coupang Eats** | **8.45M** | **#2 — fast growing** |
| Yogiyo | ~2M | distant #3 |

Baemin + Coupang Eats together hold **88.3% of Korea's delivery app market** — the highest concentration on record. Korea is now effectively a duopoly, and Coupang Eats is the side that's still gaining share, largely because every Coupang Wow membership (Coupang's Amazon-Prime equivalent, ~15M subscribers paying ₩7,890/month) bundles free Eats delivery into the subscription.

The platform is **address-gated**: every search, category browse, and store ranking is computed relative to a delivery point (latitude + longitude). The same restaurant can rank #1 in Gangnam and not appear at all in Hongdae 8 km away.

#### 🇺🇸 US equivalent

- **DoorDash** — closest by market structure (the dominant scale player whose growth was unlocked by the DashPass subscription bundle).
- **Uber Eats** — closest by parent-company logic (a delivery service riding on top of a bigger consumer platform's logistics + payments + identity).

***

### 🚀 What does this actor do?

Extracts **restaurant listings and menus** from Coupang Eats. You can:

- Provide one or more **delivery addresses** (`addresses`) — required for search/category browsing because Coupang Eats results depend on the delivery location.
- Provide **search queries** (`searchQueries`) — Korean *or* English. Use Korean (`치킨`, `피자`, `떡볶이`) for the broadest results; English (`Starbucks`, `McDonald's`, `pizza`) works for global chains and cafes with English names.
- Provide **category IDs** (`categoryIds`) — browses each category at each address.
- Provide **direct store IDs** (`storeIds`) — fetches each store; no address required.
- Mix any combination in a single run.

You give it inputs, it returns the dataset.

***

### 🍗 Why this data matters (buyer personas)

Food-delivery data has more independent buyer personas than almost any other vertical — that's what makes it a high-margin scraping target.

| Buyer | What they use the data for | Refresh cadence |
|---|---|---|
| **Hedge fund / alt-data desks** | "How many restaurants did Coupang Eats add this quarter? Is Baemin pushing harder on discounting? Use weekly catalog deltas as a leading indicator on CPNG and on the privately held Baemin parent (Woowa/DH)." | Daily / weekly |
| **Restaurant brands & franchises** | "Where is BBQ Chicken under-distributed? What's our menu pricing vs Kyochon and bhc, per district?" | Daily |
| **Brand-protection / IP teams** | "Find restaurants illegally selling our trademarked menu items or impersonating our brand." | Daily |
| **F\&B market-research firms** | "What's the average delivery fee in Gangnam vs Jeju? How often do new openings stick after 90 days?" | Weekly / monthly |
| **Restaurant SaaS (POS, ad tools)** | "Cold-call lists of independents on Coupang Eats sorted by review count — they're the ones doing volume." | Monthly |
| **Cross-border quick-commerce expansion teams** | DoorDash / Uber / Wolt strategy desks studying the Korean duopoly playbook (Wow-membership bundle). | Quarterly |
| **Logistics & last-mile** | Delivery time benchmarks per district + time-of-day; courier-supply intelligence. | Weekly |
| **Consumer-trend / agencies** | What cuisines are trending? Which delivery times are demanded most? Promotion-frequency analysis. | Weekly |

These personas pay separately, which lets you stack the same dataset into multiple revenue streams instead of competing on a single buyer.

***

### 🗾️ Example input

**Search by keyword at a single address (most common) — works in Korean *or* English:**

```json
{
  "addresses": [
    { "latitude": 37.4979, "longitude": 127.0276, "label": "Gangnam, Seoul" }
  ],
  "searchQueries": ["치킨", "피자", "Starbucks"],
  "maxPagesPerQuery": 1
}
```

**Browse categories across multiple districts:**

```json
{
  "addresses": [
    { "latitude": 37.4979, "longitude": 127.0276, "label": "Gangnam" },
    { "latitude": 37.5563, "longitude": 126.9236, "label": "Hongdae" },
    { "latitude": 35.1796, "longitude": 129.0756, "label": "Busan Seomyeon" }
  ],
  "categoryIds": ["1", "2", "3"],
  "maxPagesPerQuery": 3
}
```

**Direct store fetch by ID (no address required):**

```json
{
  "storeIds": ["461101", "837003"],
  "fetchMenu": true
}
```

**Mix everything:**

```json
{
  "addresses": [
    { "latitude": 37.4979, "longitude": 127.0276, "label": "Gangnam" }
  ],
  "searchQueries": ["치킨", "pizza"],
  "categoryIds": ["1"],
  "storeIds": ["461101"],
  "fetchMenu": true,
  "maxPagesPerQuery": 2
}
```

***

### 📦 What data do you get?

Every restaurant is returned with the following fields:

```json
{
  "store_id": "461101",
  "name": "BBQ치킨 강남점",
  "name_en": null,
  "categories": ["치킨", "한식"],
  "category_id": null,
  "rating_avg": 4.7,
  "rating_count": 1234,
  "review_count": 1234,
  "address": "서울 강남구 테헤란로 152",
  "address_road": "테헤란로 152",
  "lat": 37.4979,
  "lng": 127.0276,
  "phone": null,
  "delivery_fee_min": 0,
  "delivery_fee_max": 3000,
  "delivery_fee_text": "0원 ~ 3,000원",
  "delivery_time_min": 25,
  "delivery_time_max": 35,
  "minimum_order_amount": 15000,
  "currency": "KRW",
  "is_coupang_delivery": true,
  "is_wow_free_delivery": true,
  "is_open": true,
  "is_new": false,
  "is_promoted": false,
  "discount_badge": "20% 할인",
  "promotion_text": "신규 가입 5,000원 쿠폰",
  "thumbnail": "https://image.coupangcdn.com/.../bbq.jpg",
  "images": [],
  "hours": null,
  "menu_count": 12,
  "menu": [
    {
      "menu_item_id": "...",
      "name": "황금올리브 치킨",
      "price": 23000,
      "original_price": null,
      "description": "바삭한 후라이드 치킨",
      "thumbnail": "https://...",
      "is_signature": true,
      "is_popular": true,
      "options": []
    }
  ],
  "search_query": "치킨",
  "search_rank": 1,
  "search_address_label": "Gangnam",
  "search_lat": 37.4979,
  "search_lng": 127.0276,
  "store_url": "https://web.coupangeats.com/share?storeId=461101",
  "scraped_at": "2026-06-09T13:42:24.433Z"
}
```

#### Field reference

| Field | Type | Notes |
|---|---|---|
| `store_id` | string | Coupang Eats numeric store ID (the `storeId` in the share URL) |
| `name`, `name_en` | string | Restaurant name (Korean; English when available) |
| `categories` | array | Cuisine categories (치킨, 한식, 일식, etc.) |
| `category_id` | string | Set when the store was found via a category browse |
| `rating_avg` | number | Average review rating (0–5) |
| `rating_count` / `review_count` | number | Total review count |
| `address`, `address_road` | string | Full address and road-name address (도로명 주소) |
| `lat`, `lng` | number | Restaurant coordinates |
| `phone` | string | Phone (often null — many stores hide this) |
| `delivery_fee_min`, `delivery_fee_max` | number | Delivery fee range in KRW (varies by distance / promotions) |
| `delivery_fee_text` | string | Original humanised fee string when not numeric |
| `delivery_time_min`, `delivery_time_max` | number | Estimated delivery time in minutes |
| `minimum_order_amount` | number | Minimum order in KRW |
| `currency` | string | Always `"KRW"` |
| `is_coupang_delivery` | bool | True when delivered by Coupang's own fleet (쿠팡배달), not the restaurant's |
| `is_wow_free_delivery` | bool | True when the store qualifies for free delivery under a Coupang Wow membership |
| `is_open` | bool | Currently accepting orders |
| `is_new` | bool | Recently opened on the platform |
| `is_promoted` | bool | Paid placement (Coupang Eats ads) |
| `discount_badge` | string | E.g. `"20% 할인"` |
| `promotion_text` | string | Free-form promo text |
| `thumbnail` | string | Primary restaurant image URL |
| `images` | array | Additional images |
| `hours` | object | Operating hours per day-of-week (when available) |
| `menu_count` | number | Number of items in the menu (populated when `fetchMenu=true` or when listings inline the menu) |
| `menu` | array | Menu items with name, price, description, thumbnail, options |
| `search_query` | string | Set when the store was found via a search |
| `search_rank` | number | Position in the listing |
| `search_address_label`, `search_lat`, `search_lng` | string/number | The address slice this result was collected under |
| `store_url` | string | Public share URL — `https://web.coupangeats.com/share?storeId={store_id}` |
| `scraped_at` | string | ISO timestamp when the page was extracted |

***

### 🦖 How to use

1. Enter at least one input source — `addresses` + `searchQueries` / `categoryIds`, OR `storeIds`.
2. Optionally set `maxPagesPerQuery` (default `1`) and `fetchMenu` (default `false`).
3. Run the actor.
4. Download the results from the **Dataset** tab or fetch them via the **API**.

> **Note:** A run with 1 address × 3 queries × 1 page completes in under 10 seconds.

***

### 🔍 Key features

- **Fast** — most runs complete in seconds, not minutes.
- **Geo-aware search** — every search/category is anchored to a real delivery address, so rankings match what a Gangnam customer would actually see.
- **Three input modes** — keyword search, category browsing, and direct store fetch — mixable in one run.
- **Search in Korean or English** — Korean returns more results, English works great for global chains.
- **Structured output** — 40+ fields per restaurant, plus optional embedded menu array.
- **Automatic retries** — transient errors are retried with exponential backoff.

***

### 📋 Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `addresses` | array of `{latitude, longitude, label}` | `[]` | Delivery addresses to browse from. Required when using `searchQueries` or `categoryIds`. |
| `searchQueries` | array of strings | `[]` | Search keywords — Korean or English. Korean returns the broadest results; English works for global chains and English-named cafes. |
| `categoryIds` | array of strings | `[]` | Numeric Coupang Eats category IDs (e.g. `1` for chicken). |
| `storeIds` | array of strings | `[]` | Direct numeric store IDs — no address required. |
| `maxPagesPerQuery` | integer | `1` | Pages to walk per search/category at each address. Each page ≈ 20 stores. |
| `fetchMenu` | boolean | `false` | Attach the full menu and additional store fields to each discovered store. |
| `proxyConfiguration` | object | none | Optional. Not required for normal runs. |

#### Common address coordinates (for testing)

| District | Latitude | Longitude |
|---|---|---|
| Seoul — Gangnam Station | 37.4979 | 127.0276 |
| Seoul — Hongdae | 37.5563 | 126.9236 |
| Seoul — Itaewon | 37.5347 | 126.9947 |
| Seoul — Jongno | 37.5703 | 126.9824 |
| Busan — Seomyeon | 35.1796 | 129.0756 |
| Daegu — Dongseong-ro | 35.8693 | 128.5953 |
| Incheon — Songdo | 37.3831 | 126.6562 |
| Jeju City | 33.4996 | 126.5312 |

***

### 📩 Feedback

Found a bug or have ideas? Open an issue on the actor's Apify page — happy to improve it.

# Actor input Schema

## `addresses` (type: `array`):

Delivery addresses to browse from. Coupang Eats results depend on the delivery location — every search/category browse needs a delivery point. Each item: { latitude, longitude, label }. Example Seoul Gangnam: { "latitude": 37.4979, "longitude": 127.0276, "label": "Gangnam" }.

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

Search keywords — Korean or English. Korean (치킨, 피자, 떡볶이) returns the broadest results. English (Starbucks, McDonald's, pizza) works great for global chains and English-named cafes. Each query runs at each address.

## `categoryIds` (type: `array`):

Numeric Coupang Eats category IDs to browse at each address. Common starter: 1 (chicken).

## `storeIds` (type: `array`):

Numeric Coupang Eats store IDs. Returns the full store + menu. No address required.

## `maxPagesPerQuery` (type: `integer`):

Maximum number of result pages to collect per search/category at each address. Each page is roughly 20 stores. Default 1.

## `fetchMenu` (type: `boolean`):

If true, the actor attaches the full menu and additional store fields to each discovered restaurant. Slower but turns the dataset into a complete catalog.

## `proxyConfiguration` (type: `object`):

Optional. Not required for normal runs.

## Actor input object example

```json
{
  "addresses": [
    {
      "latitude": 37.4979,
      "longitude": 127.0276,
      "label": "Gangnam, Seoul"
    }
  ],
  "searchQueries": [
    "치킨",
    "Starbucks"
  ],
  "maxPagesPerQuery": 1,
  "fetchMenu": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `restaurants` (type: `string`):

Flat dataset of restaurants. One row per restaurant per slice (address × search query / category). Includes name, address, GPS, rating, delivery fee, ETA, minimum order, and optional embedded menu when fetchMenu=true.

## `rawSamples` (type: `string`):

First-page raw JSON response of every search/category/store source. Useful for debugging or discovering category IDs.

# 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 = {
    "addresses": [
        {
            "latitude": 37.4979,
            "longitude": 127.0276,
            "label": "Gangnam, Seoul"
        }
    ],
    "searchQueries": [
        "치킨",
        "Starbucks"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("amit123/coupang-eats-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 = {
    "addresses": [{
            "latitude": 37.4979,
            "longitude": 127.0276,
            "label": "Gangnam, Seoul",
        }],
    "searchQueries": [
        "치킨",
        "Starbucks",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("amit123/coupang-eats-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 '{
  "addresses": [
    {
      "latitude": 37.4979,
      "longitude": 127.0276,
      "label": "Gangnam, Seoul"
    }
  ],
  "searchQueries": [
    "치킨",
    "Starbucks"
  ]
}' |
apify call amit123/coupang-eats-scraper --silent --output-dataset

```

## MCP server setup

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