# Daangn Market Alerts: Karrot New Listing & Price Drop Monitor (`accountable_eel/daangn-market-alerts`) Actor

Daangn market alerts for Karrot Market in Korea: monitor a Daangn neighbourhood for new listings and price drops by keyword, such as a price drop alert for bikes on Daangn (자전거). Only new or cheaper listings since the last run. To Google Sheets or n8n. No login. Misses are free.

- **URL**: https://apify.com/accountable_eel/daangn-market-alerts.md
- **Developed by:** [Adriana Voss](https://apify.com/accountable_eel) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 daangn listing returneds

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

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 Market Alerts: Newest Listings and Price Drops From Korea's Neighbourhood Marketplace

Search Daangn (Karrot Market) for a keyword and get the newest listings as rows: title, full description, price in won, the neighbourhood, and a link. Add monitoring and a scheduled run returns only what is new or cheaper since the run before. Each search is capped at the 50 newest listings unless you raise it.

### Who it's for

**A Seoul reseller who flips used bicycles and laptops.** You know what a good price for a given frame or MacBook model is. What you lack is speed: the underpriced ones are gone within the hour, and you cannot sit on the app. You want a feed that pings your phone when a matching listing appears under your ceiling price.

**A foreigner furnishing a first apartment in Seoul.** Your Korean is basic, but you know the nouns you need: 냉장고, 책상, 침대. You set up three searches, let them run each morning, and only look at the new rows.

**A pricing analyst for a trade-in programme.** You want the going rate for a handful of used device models in one district, tracked week after week, without copying prices from the app.

### Why this one

- **Korean keywords, native results.** Search terms go to Daangn's own search in Korean. Titles, descriptions and neighbourhood names come back untranslated.
- **Won, as a number.** `price` is numeric and `currency` is `KRW`, so a budget ceiling is a spreadsheet filter.
- **A spending cap on every search.** The 50-listing default keeps one broad keyword from billing hundreds of rows. The next section explains why that matters.
- **Alerts for both events.** New listings and price drops (5% or more by default) can be switched on or off separately.

### What you get

| Field | Meaning |
| --- | --- |
| `listingId` | The id at the end of the listing address. |
| `title`, `description` | The seller's title and full text. Descriptions can run to many lines. |
| `price`, `currency` | Asking price in won as a number, and `KRW`. |
| `region` | Daangn's neighbourhood name for the listing. |
| `url`, `imageUrl` | The listing page and its thumbnail. |
| `listingStatus` | Daangn's status for the listing, `Ongoing` when none is given. |
| `createdAt` | When the listing was created, as an ISO timestamp. |
| `isNew`, `changeType` | In monitoring mode: `new`, `price_drop` or `seen`. |
| `previousPrice`, `priceDropPct` | Filled on a price drop. |
| `firstSeen`, `lastSeen` | When this monitor first and last saw the listing. |

### Why 50 listings per search

A single Daangn search is not small. On 2026-10-08 the keyword 자전거 (bicycle) matched 267 listings on one results page, with no page two to fetch. Every returned listing is billed, so a plain search at $0.002 each could cost about $0.53 per run, per keyword, before you have decided whether you want that many.

So each search is cut to the first 50 listings in the order the page lists them, by default. The cut has three consequences worth knowing:

1. **The ceiling is predictable.** One search can cost at most 50 × $0.002 = $0.10 at the default. Three keywords on a daily schedule are at most thirty cents a day, and usually far less once monitoring is on.
2. **Cut listings are not recorded as seen.** The cap is applied before the monitoring record is updated, so a listing that fell outside the first 50 has not been used up. If it later moves into the first 50, it arrives as new.
3. **You can lift it.** Set `maxPerSearch` higher to take more of the page, or lower to spend less. `maxResults`, if set, applies as a second, smaller cap. The page itself held only about 270 listings, so raising the limit beyond that changes nothing.

The price and budget filters (`minPrice`, `maxPrice`) run before the cap, so the 50 you get are the 50 that already pass your price window.

### Pricing

- **Daangn listing returned**: $2 per 1,000 listings

Plus a $0.003 start fee per run. Each event above is billed independently, only when it actually returns data — misses (`found:false`) are never charged.

### How to use

1. **In the Apify Console.** Open the actor page and click **Start** — the `searches` field is already pre-filled with a working example. Results land in the run's dataset as soon as each item is found.
2. **Via the API.** Call it directly with a POST request — no Console needed once you have an API token:
   ```bash
   curl "https://api.apify.com/v2/acts/accountable_eel~daangn-market-alerts/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
     -X POST \
     -H "Content-Type: application/json" \
     -d '{"searches":["자전거"]}'
   ```
3. **On a schedule.** Save this actor as an Apify **Task** with the input you want, then add a **Schedule** (hourly, daily, weekly) so it runs on its own — no server of your own required.

Write the keyword in Korean for the best match. For ongoing alerts, switch on `deltaMode`, add `skipFirstRun` if you want the first run to bank the current listings without returning them, and schedule the actor.

### Input

```json
{
  "searches": [
    "자전거"
  ]
}
```

One search per line. E.g. "자전거", "아이폰", "맥북". Accepted formats: 자전거, 아이폰, 맥북.

Other settings: `regionId` and `regionName` (the neighbourhood the search is made from), `minPrice` and `maxPrice` (won; listings without a price are dropped when either is set), `maxPerSearch`, `alertOnNew`, `alertOnPriceDrop`, `minPriceDropPct`, `deltaMode`, `deltaName`, `skipFirstRun`, `includeKeywords` and `excludeKeywords` (matched against the row text) and `maxResults`.

**Choosing a neighbourhood.** Daangn reads the region from a cookie, and the actor sets it from `regionId` and `regionName`. The defaults are 서초4동 and 366 (Seocho 4-dong, Seoul). In Daangn's own web addresses the region appears as `in=<name>-<id>`, for example `in=서초4동-366`, so copy the name and number from there. Neighbouring ids on the same page were 363, 364 and 365 for 서초1동, 서초2동 and 서초3동. In our default-region test, the newest listing came from 양재1동, a nearby district, so expect nearby areas and not a single dong.

### Sample output

| query | found | status | searchQuery | listingCount | newCount | priceDropCount | listings | listingId | title | description | price | currency | region | url | imageUrl | listingStatus | createdAt | isNew | changeType | previousPrice | priceDropPct | firstSeen | lastSeen | scrapedAt |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 자전거 | true | OK | <search query> | <listings returned> | <new listings> | <price drops> | <listings> | <listing id> | <title> | <description> | <price> | <currency> | <region> | <listing url> | <image url> | <status> | <created at> | <is new> | <change type> | <previous price> | \<price drop %> | <first seen> | <last seen> | 1970-01-01T00:00:00.000Z |

A search with no listings returns one row with `listingCount: 0` and is not billed.

### Use it from Clay, n8n, Make, or an AI agent

This actor runs synchronously over plain HTTP — call it directly from a script, a workflow tool, or an AI agent, no Apify Console needed once you have an API token.

```bash
curl "https://api.apify.com/v2/acts/accountable_eel~daangn-market-alerts/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"searches":["자전거"]}'
```

**n8n.** Add an HTTP Request node: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~daangn-market-alerts/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body Content Type `JSON`, JSON Body `{"searches":["자전거"]}` (swap in an expression from an earlier node for a real value).

**Clay.** Add an "HTTP API" column: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~daangn-market-alerts/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body `{"searches":["{{search}}"]}`, mapping the row's search into the `searches` array.

**MCP.** In Claude, Cursor, or any MCP client with the Apify MCP server, ask for "Daangn Market Alerts | Apify" — the agent will find and run this actor.

### Tips

- **Set a price ceiling.** Alerts are most useful with a `maxPrice`. Without one, a popular keyword refills the 50 slots with listings you do not want.
- **Use specific model names.** "맥북 에어 M2" returns a tighter set than "맥북".
- **A burst of requests may come back empty.** During repeated local testing from one home connection, Daangn started returning a short page with no listings. The actor reports that as zero listings with no charge; if you see it, wait and run again.
- **Watch several keywords with one `deltaName`.** The record is kept per keyword inside the shared name, so adding a keyword later does not reset the others.
- **Photos are thumbnails.** `imageUrl` is the thumbnail Daangn attaches to the listing.

### vs. alternatives

| | What it costs | What you get | Trade-off |
| --- | --- | --- | --- |
| **This actor** (`daangn-market-alerts`) | $0.002 per listing returned, $0.003 per run, 50 listings per search by default | The newest listings per keyword with monitoring for new and reduced items | Fewer fields and fewer filters than the sibling, and the 50-listing default leaves the rest of the page unread |
| **Daangn Listing Lookup** (`daangn-listing-lookup`) | $0.002 per listing returned, listed at the same rate | Up to about 275 listings per search, city and title filters, sorting, posted and boosted times, and the same monitoring | The better choice if you want the whole page or more filters. Pick this actor only if you want the lower default spend. |

The sibling's price and limits are those on its page at the time of writing; check them there.

### FAQ

#### Why is my first monitored run full of rows?

Because everything on the page is new to an empty record. Use `skipFirstRun` to bank the current listings without returning them.

#### Does it return sold items?

The `listingStatus` column carries whatever status Daangn reports, falling back to `Ongoing`. The actor does not filter on it.

#### Can I search in English?

You can, but Daangn's catalogue is in Korean, so Korean terms find far more.

#### Does a quiet run cost anything?

Only the $0.003 start fee, because no listing is returned.

### Related actors

- [Daangn Listing Lookup](https://apify.com/accountable_eel/daangn-listing-lookup) is the deeper version with more filters and about 275 listings per search.
- [Bunjang Listing Lookup](https://apify.com/accountable_eel/bunjang-listing-lookup) covers another Korean second-hand marketplace.
- [Joonggonara Listing Lookup](https://apify.com/accountable_eel/joonggonara-listing-lookup) covers a third.

# Actor input Schema

## `searches` (type: `array`):

One search per line. E.g. "자전거", "아이폰", "맥북". Accepted formats: 자전거, 아이폰, 맥북. You're only charged for the ones we actually find — a miss costs nothing.

## `testRun` (type: `boolean`):

Turn this on to test your input on a small sample before running the full list. Turn it off to process everything.

## `onlyFound` (type: `boolean`):

Only keep rows where something was actually found. Misses are always free, whether or not you show them here.

## `includeKeywords` (type: `array`):

Optional. Only keep results that mention at least one of these words (e.g. a job title, a city, a product name). Leave empty to keep everything.

## `excludeKeywords` (type: `array`):

Optional. Drop any result that mentions one of these words. Leave empty to skip nothing.

## `maxResults` (type: `integer`):

Optional. Stop the run once this many results have been found — useful for a quick, cheap sample. Leave blank for no limit.

## `regionId` (type: `string`):

Daangn neighbourhood region ID code (default "366" for 서초4동).

## `regionName` (type: `string`):

Daangn neighbourhood region display name (default "서초4동").

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

Optional minimum price filter in KRW.

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

Optional maximum price filter in KRW.

## `deltaMode` (type: `boolean`):

When enabled, only returns listings that are new or dropped in price since last run.

## `deltaName` (type: `string`):

Optional custom state key for KV store memory.

## `alertOnNew` (type: `boolean`):

Emit alerts when new listings appear.

## `alertOnPriceDrop` (type: `boolean`):

Emit alerts when listing prices drop.

## `minPriceDropPct` (type: `integer`):

Minimum price drop percentage to trigger an alert.

## `maxPerSearch` (type: `integer`):

One Daangn search can match hundreds of listings. Only the newest this many are returned (and charged) for each search. Default 50.

## `skipFirstRun` (type: `boolean`):

Silently seed initial state without emitting alerts on first run.

## `columns` (type: `array`):

Choose which pieces of information to include in each result row. All are included by default.

## `expandRows` (type: `boolean`):

When on, each listing found gets its own row instead of being grouped under its search. You're still only charged once per search, no matter how many rows it produces.

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

Parallel requests. Keep conservative — this target has no browser fallback, so getting blocked costs more than slow-and-steady.

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

Apify Proxy config. Residential recommended for anti-bot-sensitive targets.

## Actor input object example

```json
{
  "searches": [
    "자전거"
  ],
  "testRun": false,
  "onlyFound": false,
  "includeKeywords": [],
  "excludeKeywords": [],
  "regionId": "366",
  "regionName": "서초4동",
  "deltaMode": false,
  "deltaName": "",
  "alertOnNew": true,
  "alertOnPriceDrop": true,
  "minPriceDropPct": 5,
  "maxPerSearch": 50,
  "skipFirstRun": false,
  "columns": [
    "searchQuery",
    "listingCount",
    "newCount",
    "priceDropCount",
    "listings",
    "listingId",
    "title",
    "description",
    "price",
    "currency",
    "region",
    "url",
    "imageUrl",
    "listingStatus",
    "createdAt",
    "isNew",
    "changeType",
    "previousPrice",
    "priceDropPct",
    "firstSeen",
    "lastSeen"
  ],
  "expandRows": true,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (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 = {
    "searches": [
        "자전거"
    ],
    "includeKeywords": [],
    "excludeKeywords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("accountable_eel/daangn-market-alerts").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 = {
    "searches": ["자전거"],
    "includeKeywords": [],
    "excludeKeywords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("accountable_eel/daangn-market-alerts").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 '{
  "searches": [
    "자전거"
  ],
  "includeKeywords": [],
  "excludeKeywords": []
}' |
apify call accountable_eel/daangn-market-alerts --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,accountable_eel/daangn-market-alerts"
        }
    }
}
```

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/HxGVn9ExivaXA3XOh/builds/xUOo8cHkJnguMkOAx/openapi.json