# Daangn Scraper - Karrot Used Price Index (Korea Second-hand) (`koreadata-lab/daangn-used-price-index`) Actor

What does it sell for used in Korea? Median, P10-P90 and trimmed mean of Daangn Market (Karrot) asking prices per keyword and neighborhood, with relevance filters. Public search pages only, no seller data.

- **URL**: https://apify.com/koreadata-lab/daangn-used-price-index.md
- **Developed by:** [Koreadata Lab](https://apify.com/koreadata-lab) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $30.00 / 1,000 price index rows

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

## Daangn Scraper - Karrot Used Price Index (Korea Second-hand)

**What does it sell for used in Korea?** This Daangn scraper (also searched as a Karrot scraper) turns **Daangn Market (당근마켓, "Karrot")** public search results into a **price index of Korean used prices**: median, P10 to P90 percentiles and an outlier-trimmed mean of second-hand asking prices per keyword and per neighborhood. Relevance filters remove accessories, parts, wanted ads and placeholder prices before the stats are computed.

> **Live-tested on Apify: YES (2026-10-29).** "아이폰15" gave a median of 630,000 KRW and "닌텐도 스위치" 200,000 KRW from the public search page.

### Why this actor

- **An answer, not a pile of listings:** one row per keyword and region, with clean statistics.
- **Relevance filters that matter on Daangn:** the search is fuzzy (searching 아이폰15 also returns iPhone 6S and cases). Title-must-match, exclude words, a minimum price and a below-median filter keep the stats honest.
- **Privacy by design:** no seller names or profiles, no listing descriptions (they often contain phone numbers and addresses), no coordinates and no photos. Optional listing rows contain only title, price, status, neighborhood, posted time and URL.
- **Polite:** respects robots.txt, 1 request every ~4 s, a single concurrent request.

### Input

```json
{ "keywords": ["아이폰15", "닌텐도 스위치"], "regions": ["반포본동-368"], "excludeWords": ["케이스", "부품용", "삽니다"], "outputListings": false }
```

`regions` are Daangn region slugs from the website URL (`?in=반포본동-368`). Leave it empty for Daangn's default results.

### Output (price_index row)

Example (illustrative values). Out of 5 listings found, the filters kept 2: a case, a "부품용" (for parts) phone and a free giveaway were dropped.

```json
{
  "recordType": "price_index", "keyword": "아이폰15", "region": null,
  "listingsFound": 5, "listingsUsedForStats": 2,
  "all": { "count": 2, "min": 570000, "p10": 574000, "p25": 580000, "median": 590000, "p75": 600000, "p90": 606000, "max": 610000, "mean": 590000, "trimmedMean": 590000, "outliersRemoved": 0 },
  "onSale": { "count": 1, "min": 570000, "p10": 570000, "p25": 570000, "median": 570000, "p75": 570000, "p90": 570000, "max": 570000, "mean": 570000, "trimmedMean": 570000, "outliersRemoved": 0 },
  "sold": { "count": 1, "min": 610000, "p10": 610000, "p25": 610000, "median": 610000, "p75": 610000, "p90": 610000, "max": 610000, "mean": 610000, "trimmedMean": 610000, "outliersRemoved": 0 },
  "currency": "KRW",
  "sourceUrl": "https://www.daangn.com/kr/search/buy-sell/?q=%EC%95%84%EC%9D%B4%ED%8F%B015",
  "fetchedAt": "2026-10-29T06:00:00.000Z"
}
```

`onSale` covers listings still for sale; `sold` covers sold and reserved ones (on live pages it is usually empty, see Limitations). With `outputListings: true` you also get one `listing` row per listing (`title`, `priceKrw`, `status`, `neighborhood`, `postedAt`, `url`).

### Pages used

- `https://www.daangn.com/kr/search/buy-sell/?q={keyword}&in={region}`: public, no login, allowed by robots.txt for generic user agents. Data is read from the page's embedded JSON (`__remixContext`), with the schema.org `ld+json` ItemList as a fallback.

### Limitations

- **These are asking prices, not transaction prices.** Daangn's public search shows on-sale listings only, so `sold` is usually empty.
- One search page shows about 270 to 300 listings. There is no deeper pagination on the public page.
- The keyword's "region" depends on Daangn's own location logic. Results may include nearby neighborhoods.
- Daangn could change its page structure. Parsing has a fallback, and the run warns if 0 listings are parsed.

### API keys

None. This actor reads public pages only, takes no credentials and stores none.

### Pricing (pay per event)

- `price-index`: **$30.00 per 1,000 index rows** ($0.03 per row). One row is one keyword in one region and summarizes up to ~300 listings.
- `listing`: **$1.00 per 1,000 listings** (only if `outputListings` is on).
- Actor start: Apify's synthetic `apify-actor-start` event, a fraction of a cent per run.
- **Platform usage is included.** You pay only the event prices above; the Apify compute of the run is not billed to you separately.
- Set **Max total charge** for a run to cap spend; the actor stops early when it is reached.

### FAQ

**Do I need an API key or a Daangn account?**
No. The actor reads Daangn's public search page, with no login and no key.

**How fresh is the data?**
Each run loads the search page live, so the index reflects the listings shown on Daangn at that moment. Nothing is cached between runs.

**Can I schedule it daily?**
Yes. An Apify Schedule with the same keywords gives you one index row per keyword and region per day, which you can chart as a used-price trend. Note that each run is a fresh snapshot; the actor does not compare with the previous run.

**What does a typical run cost?**
One keyword costs $0.03. 10 keywords in 3 regions (30 index rows) cost about $0.90. Adding raw listings for one keyword (about 300 rows) adds about $0.30.

**Is this legal, and where does the data come from?**
The data comes from Daangn's public search pages, which robots.txt allows for generic crawlers. The actor does not log in, collects no seller data, and crawls slowly. It is not affiliated with Daangn (Karrot); you are responsible for how you use the results.

# Actor input Schema

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

Product keywords in Korean, e.g. 아이폰15, 다이슨 에어랩, 닌텐도 스위치. Max 30.

## `regions` (type: `array`):

Daangn region slugs as they appear in the site URL after in=, e.g. 반포본동-368. Empty = Daangn's default nationwide/popular results. Max 20.

## `excludeWords` (type: `array`):

Drop accessories, parts and wanted-ads from the price stats. Matching is case-insensitive.

## `minPriceKrw` (type: `integer`):

Ignore listings below this price (free giveaways = 0 are always ignored for stats).

## `maxPriceKrw` (type: `integer`):

Ignore listings above this price. 0 = no limit.

## `requireKeywordInTitle` (type: `boolean`):

Daangn search is fuzzy (searching 아이폰15 also returns 아이폰 6S). When on, only listings whose title contains every word of the keyword (spaces ignored) are used for the stats.

## `belowMedianRatio` (type: `string`):

Removes placeholder prices (e.g. '88' meaning 880,000) and accessories that slipped through. 0.3 = drop listings cheaper than 30% of the median. Set 0 to disable.

## `outputListings` (type: `boolean`):

Output one row per listing (title, price, status, neighborhood, posted time, URL). Seller identity, description text, photos of people and coordinates are never output.

## `maxListingsPerQuery` (type: `integer`):

Daangn's public search page shows up to roughly 300 listings.

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

Optional. Apify Proxy datacenter is usually enough; the actor is slow on purpose (1 request every ~4 s).

## Actor input object example

```json
{
  "keywords": [
    "아이폰15",
    "닌텐도 스위치"
  ],
  "regions": [],
  "excludeWords": [
    "케이스",
    "부품용",
    "삽니다",
    "구매합니다",
    "필름",
    "case",
    "삽니당"
  ],
  "minPriceKrw": 1000,
  "maxPriceKrw": 0,
  "requireKeywordInTitle": true,
  "belowMedianRatio": "0.3",
  "outputListings": false,
  "maxListingsPerQuery": 300,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

All result rows in the default dataset.

# 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 = {
    "keywords": [
        "아이폰15",
        "닌텐도 스위치"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("koreadata-lab/daangn-used-price-index").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 = { "keywords": [
        "아이폰15",
        "닌텐도 스위치",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("koreadata-lab/daangn-used-price-index").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 '{
  "keywords": [
    "아이폰15",
    "닌텐도 스위치"
  ]
}' |
apify call koreadata-lab/daangn-used-price-index --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,koreadata-lab/daangn-used-price-index"
        }
    }
}
```

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/whyzB2FJrg3ApaSMo/builds/eDPyP586EwCux2YLc/openapi.json