# Danawa Scraper — Korean Price Comparison (danawa.com) (`kdatafactory/danawa-scraper`) Actor

Scrape Danawa (다나와), Korea's #1 electronics & product price-comparison site: product name, lowest KRW price, category, brand, spec summary and image as clean JSON. Search any keyword. Public price-comparison data only — no PII. Ideal for price monitoring, MAP, repricing and market research.

- **URL**: https://apify.com/kdatafactory/danawa-scraper.md
- **Developed by:** [Seok June Park](https://apify.com/kdatafactory) (community)
- **Categories:** E-commerce, Automation
- **Features:** Limited permissions
- **Stats:** 10 total users, 3 monthly users, 92.5% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.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

## Danawa Scraper — Korean Price Comparison 💻

Scrape live **product price-comparison data** from [Danawa (다나와)](https://www.danawa.com) — Korea's **#1 electronics & product price-comparison site** — as clean, structured JSON. Search any keyword and get the product name, **lowest listed KRW price**, category, brand, spec summary, and image for every result in one run.

The go-to source for **price monitoring, MAP enforcement, repricing, and market research** on the Korean market. Danawa aggregates prices across hundreds of malls, so its lowest-price figure is the reference point Korean shoppers and sellers actually use.

> **Try it free.** Apify's free plan includes $5 of monthly platform credit — at **$4.00 / 1,000 results** that's roughly **1,250 products** from this actor, no credit card required. Set your keyword, click Start, and export JSON/CSV/Excel.

***

### What it does

This actor reads product data straight from Danawa's own public search results (the same page the website renders as you search), so results are fast and complete — no headless browser. For any keyword you give it, you get a structured, filterable list of matching products with their lowest aggregated price. You can scrape:

- **Any search keyword** — `노트북` (laptop), `아이폰`, `RTX 4070`, `무선청소기`, a brand, a model number — anything Danawa's search box accepts, in Korean or English.
- **As many results as you want** — the actor paginates through Danawa's results (≈40 products per page) up to your `maxItems`.

> **Why Danawa?** Danawa is Korea's dominant price-comparison portal for electronics, appliances, and thousands of other categories. Its "최저가" (lowest price) is aggregated across hundreds of online malls, making it the single best public reference for what a product actually costs in Korea. This actor turns that into a dataset you can filter, price-model, and pipe into your own tools.

***

### Input

| Field | Type | Description |
|-------|------|-------------|
| `query` | string | The search keyword, exactly as you'd type it into Danawa. Korean **or** English — e.g. `노트북`, `아이폰 15`, `RTX 4070`, `무선청소기`. Defaults to `노트북`. |
| `maxItems` | integer | Max products to collect. Default `100`, max `10000`. |
| `proxyConfiguration` | object | Proxy settings (see below). Optional — defaults to a direct connection, and the actor switches to Apify Proxy by itself if the direct IP gets blocked. |

#### Input example

```json
{
  "query": "노트북",
  "maxItems": 200
}
```

```json
{
  "query": "RTX 4070",
  "maxItems": 500
}
```

***

### Output

Each product is one dataset record. `price_krw` is the **lowest listed price** in Korean won (Danawa's aggregated 최저가), as a plain integer. `spec_summary` is Danawa's short spec line for the product when shown. `category` is the product's Danawa category path.

```json
{
  "source": "danawa",
  "product_id": "106749749",
  "name": "레노버 요가 Slim 7i Ultra Aura Edition 83QK001JKR",
  "price_krw": 2798000,
  "category": "디지털 완제품 > 노트북",
  "brand": "레노버",
  "spec_summary": "AI노트북/ 35.56cm(14인치)/ 975g/ 최대 26.5시간/ sRGB: 100%/ Adobe RGB: 100%/ DCI-P3: 100%/ 500nit/ 인텔/ 코어 울트라5(S3)/325 (4.5GHz)/ 47TOPS/Intel Graphics/ 32GB/ 램 교체: 불가능/ 용량: 1TB/출시가: 2,607,600원",
  "mall_count": 18,
  "url": "https://prod.danawa.com/info/?pcode=106749749",
  "image_url": "https://img.danuri.io/catalog-image/749/749/106/421c8dbfe7db4eb4a3228e1a88536850.jpeg",
  "scraped_at": "2026-08-24T08:22:51+09:00"
}
```

A full 40-item sample from a real run is in [`samples/sample-output.json`](samples/sample-output.json).

| Field | Meaning |
|-------|---------|
| `source` | Always `"danawa"`. |
| `product_id` | Danawa product code (`pcode`). |
| `name` | Full product name, as Danawa lists it. |
| `price_krw` | Lowest listed price in KRW (integer). |
| `category` | Danawa category path (e.g. `디지털 완제품 > 노트북`), else `null`. |
| `brand` | Best-effort brand (first token of the name), else `null`. |
| `spec_summary` | Danawa's short spec line when shown, else `null`. |
| `mall_count` | Number of sellers listing the product (Danawa's `N몰` badge), else `null`. |
| `url` | Product detail page URL. |
| `image_url` | Main product image URL, else `null`. |
| `scraped_at` | ISO-8601 timestamp (KST, UTC+9). |

Every field above was populated on **40/40** records in the live test of 2026-08-24, `mall_count` and `spec_summary` included. `brand` and `spec_summary` remain best-effort by nature (see Known limitations).

***

### Use cases

- **Price monitoring & MAP enforcement** — track a product's Danawa 최저가 (lowest price) over time to detect price drops and catch resellers breaking your Minimum Advertised Price.
- **Reseller & arbitrage sourcing** — scan a category or keyword for underpriced listings versus their typical Danawa price, and spot cross-border arbitrage opportunities.
- **E-commerce repricing** — feed live Korean market prices into your own repricing engine so your storefront always tracks the reference lowest price.
- **Market & competitive research** — measure price distribution, brand mix, and product availability across a keyword or category on Korea's biggest price portal.
- **AI agents & datasets** — feed structured product + price data into pricing models, dashboards, or LLM agents.

***

### ❓ FAQ

**Is it legal to scrape this data?**
This actor collects only public, non-personal price-comparison data — the same product listings any visitor sees on danawa.com without logging in. No personal or individual-seller contact data is collected. You are responsible for how you use the data; see the legality note below.

**What does it cost in practice?**
$4.00 per 1,000 results + a few cents of platform usage. Example: a 500-result daily pull costs about **$2.00/day**. Apify's free $5 monthly credit covers **~1,250 results** (5 ÷ 4.00 × 1,000).

**Do I need to configure proxies?**
No. The default is a **direct connection**, and if Danawa's WAF blocks that IP the actor retries with backoff and automatically escalates to Apify Proxy on a fresh IP — a transient block no longer fails the run. Configuring a proxy yourself is still worthwhile for very heavy pulls.

**How fresh is the data?**
Every run scrapes the live Danawa results at run time. Schedule the actor for recurring snapshots (e.g. daily price tracking).

**What is NOT included?**
Per-seller price rows and individual mall contact details are not returned — only the product, its aggregated lowest price and how many malls list it. `spec_summary` and `brand` are best-effort (see Known limitations). Product names, categories, and specs come as Korean strings, as Danawa lists them.

***

### 🤖 Use with AI agents (MCP)

Call this Actor as a tool from Claude or any MCP-compatible AI agent — no glue code. Point your MCP client at Apify's server, scoped to this Actor:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=kdatafactory/danawa-scraper",
      "headers": { "Authorization": "Bearer <YOUR_APIFY_TOKEN>" }
    }
  }
}
```

Your agent can then pull Danawa product prices and market data on demand — no scraping code in your app. Grab a free token from [Apify → Integrations](https://console.apify.com/settings/integrations).

### 🇰🇷 More Korean data actors

This actor is part of a suite of Korean-platform scrapers by the same maintainer:

- [kurly-scraper](https://apify.com/kdatafactory/kurly-scraper) — product & price data from Market Kurly, Korea's leading premium grocery platform.
- [musinsa-scraper](https://apify.com/kdatafactory/musinsa-scraper) — fashion product listings from Musinsa, Korea's #1 online fashion store.

Browse all: [apify.com/kdatafactory](https://apify.com/kdatafactory)

***

### Rate limiting & legality

- The actor collects **only public, non-authenticated data**. It never logs in and never touches private endpoints.
- **No personal data** is collected. Only product attributes and an aggregated lowest price are returned — never individual seller contact information.
- Requests are rate-limited: one page at a time with a ≥ 500 ms delay between requests, to stay gentle on Danawa's servers.
- You are responsible for using the data in line with Danawa's terms of service and applicable law.

#### Reliability & blocking

Danawa's WAF intermittently answers datacenter IPs with a block page — sometimes as HTTP 403, sometimes as HTTP 200 carrying an interstitial instead of results. It is transient — the same input succeeds minutes later — so the actor treats it as a retry, not a failure:

1. Up to **7 attempts** per page with exponential backoff (≈2s → 8s, capped so the ladder cannot outlive your run timeout).
2. From the **2nd attempt** it **escalates to Apify Proxy** on a fresh session/IP, even when you configured no proxy. (Attempts 1 and 2 used to both leave from the same container IP, which wasted one attempt proving what the first already showed.)
3. A 200 response carrying a block interstitial is caught by **what the page is**, not by how big it is, so a blocked run can never masquerade as an empty result.

**Every failure message states what was actually observed** and whether a proxy can help, because they are not interchangeable:

| What Danawa returned | What it means | Does a proxy help? |
| --- | --- | --- |
| `403` / `429` | genuine block or rate limit | **yes** — fresh IP + backoff |
| `5xx` | Danawa's own server erred | no — backoff only |
| `404` | the endpoint was retired | **no** — the actor needs a code update |
| `200`, empty body | rejected at the CDN edge on request shape | **no** — the headers must change |
| `200`, not a results page | WAF interstitial / home page | **yes** — fresh IP |
| `200`, a real results page with no cards | Danawa changed the product markup | **no** — the parser needs updating |

Failures that are *not* transient stop immediately with an explicit message instead of burning retries — a keyword with no matches on Danawa reports exactly that.

#### Two live page layouts (2026-10)

Danawa is migrating search from the legacy `dsearch.php` template to a React rebuild at `search.danawa.com/?query=…`, and `dsearch.php` redirects a share of traffic to it. The rollout is partial, so either layout can answer any given request. **This actor parses both and emits the identical row shape** — same field names, same types, same ordering, and verified identical `product_id`, `price_krw`, `mall_count` and `image_url` for the same products.

One value does differ by layout, and Danawa gives no way to reconcile it: **`category`**. The legacy page carries the top-level path (`디지털 완제품 > 노트북`); the React page carries the leaf path (`노트북 > 노트북 전체`). Both are valid Danawa category paths for the same product. If you key on `category`, match on substrings rather than on the exact string until the migration finishes.

#### Known limitations (honesty note)

- **`mall_count`** (number of sellers) is read from the `N몰` badge on the price list and was present on 40/40 rows in the 2026-08-24 test. Until that date the actor looked for an older `판매처 N` wording that Danawa no longer uses, so earlier runs returned `null` here; it is still declared nullable because Danawa omits the badge on single-seller listings.
- **`brand`** is derived **heuristically** as the first token of the product name (e.g. `LG전자`, `ASUS`, `삼성전자`). It's right for the vast majority of listings, but Danawa has no dedicated brand field on the card, so treat it as best-effort. The authoritative full product name is always in the `name` field.
- **`spec_summary`** is Danawa's raw short spec line, lightly cleaned. It's present for most products but its format varies by category (and is occasionally empty), so it's best-effort and can be `null`.
- **`category`** is derived from Danawa's category metadata on the card. It's populated for the vast majority of products but can be `null` for the occasional result that omits it. Its granularity depends on which of the two live page layouts answered the request — see *Two live page layouts* above.
- **Names, categories, and specs are Korean strings**, exactly as Danawa lists them — they are not translated.

***

*If this actor saves you time, a rating on the [Store page](https://apify.com/kdatafactory/danawa-scraper) helps a solo maintainer a lot. Found an issue? Open it in the Issues tab — I respond fast.*

***

### ⭐ Found it useful?

If this Actor saves you time, a short review on its Apify Store page helps other buyers find it. Missing a field or hit a bug? Open an issue on the **Issues** tab; reports are answered and fixed.

# Actor input Schema

## `query` (type: `string`):

The product search keyword to scrape, exactly as you'd type it into Danawa's search box. Korean or English, e.g. '노트북' (laptop), '아이폰', 'RTX 4070', '무선청소기'. Defaults to '노트북' if left blank.

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

Maximum number of product records to collect (Danawa returns 40 products per page).

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

Proxy settings. The actor starts on a direct connection and that works for most runs. If Danawa's WAF blocks the IP, it retries with backoff and automatically escalates to Apify Proxy on a fresh IP, so you do not have to configure anything. Enable a proxy here to route every request through it from the first attempt — worth it for heavy or scheduled pulls.

## Actor input object example

```json
{
  "query": "노트북",
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Every record collected in this run.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("kdatafactory/danawa-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("kdatafactory/danawa-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 '{}' |
apify call kdatafactory/danawa-scraper --silent --output-dataset

```

## MCP server setup

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