# Joongna Scraper: Korea Secondhand Marketplace (중고나라) (`kdatafactory/joongna-scraper`) Actor

Scrape Joongna (중고나라), Korea's largest secondhand marketplace: keyword search and category browse for product names, KRW prices, images, wish/chat counts, and sale status as clean JSON. Powered by Joongna's search API. No seller identity collected.

- **URL**: https://apify.com/kdatafactory/joongna-scraper.md
- **Developed by:** [Seok June Park](https://apify.com/kdatafactory) (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 $2.50 / 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/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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## Joongna Scraper 🛍️

Scrape **secondhand listings** from [Joongna](https://web.joongna.com) (중고나라) — Korea's largest-breadth peer-to-peer secondhand marketplace — as clean, structured JSON. Get product names, KRW prices, images, wishlist & chat engagement counts, free-shipping flags, and listing timestamps in one call.

Built for **secondhand price research**, **resale & arbitrage sourcing**, and **Korean-market demand analysis**.

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

---

### What it does

This actor pulls listing data directly from Joongna's public search API (the same one that powers web.joongna.com), so results are fast and complete — no fragile HTML scraping in the happy path. Two modes:

- **Search** — every listing matching a keyword (e.g. `nike`, `아이폰`, `jordan 1`).
- **Category** — browse the newest / most-relevant listings in a top-level Joongna category (e.g. Women's fashion, Digital/Electronics, Star goods).

Four sort orders are supported: recommended/relevance, newest, price low→high, and price high→low.

> **Privacy first:** this actor collects **item data only**. It never emits seller nicknames, IDs, store handles, profiles, or manner-temperature. Item, price, image, and public engagement counts only.

---

### Input

| Field | Type | Description |
|-------|------|-------------|
| `mode` | string | `"search"` or `"category"`. |
| `query` | string | **Search mode:** the keyword to search for. Required in search mode. |
| `categorySeq` | integer | **Category mode:** the Joongna top-level category id (required). |
| `order` | string | `"score"` (recommended), `"date"` (newest), `"price_asc"`, or `"price_dsc"`. Default `score`. |
| `maxItems` | integer | Max listings to collect. Default `100`. |
| `proxyConfiguration` | object | Proxy settings. Apify RESIDENTIAL recommended for large runs. |

#### Common category IDs

| ID | Category |
|------|----------|
| `1` | Women's fashion |
| `2` | Men's fashion |
| `6` | Beauty |
| `8` | Digital / Electronics |
| `10` | Sports / Leisure |
| `21` | Star goods (K-pop) |

#### Input example

```json
{
  "mode": "search",
  "query": "나이키",
  "order": "date",
  "maxItems": 100
}
````

```json
{
  "mode": "category",
  "categorySeq": 1,
  "order": "score",
  "maxItems": 200
}
```

***

### Output

Each listing is one dataset record. Prices are in KRW (Korean won).

```json
{
  "source": "joongna",
  "listing_id": "229960164",
  "name": "나이키 두들 스니커즈 화이트 32",
  "price_krw": 190000,
  "status": "selling",
  "category": null,
  "region": null,
  "free_shipping": false,
  "wish_count": 8,
  "chat_count": 4,
  "url": "https://web.joongna.com/product/229960164",
  "image_url": "https://img2.joongna.com/media/original/2026/06/24/1782273653522xD4_01ech.jpg",
  "listed_at": "2026-07-09T13:23:45+09:00",
  "scraped_at": "2026-07-09T13:23:54+09:00"
}
```

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

| Field | Meaning |
|-------|---------|
| `source` | Always `"joongna"`. |
| `listing_id` | Joongna listing id (seq). |
| `name` | Listing title. |
| `price_krw` | Asking price (KRW). |
| `status` | Sale status. The search feed only returns on-sale items, so this is effectively always `"selling"` (see Known limitations). |
| `category` | Always `null` from the search feed — see Known limitations. |
| `region` | Always `null` from the search feed — see Known limitations. |
| `free_shipping` | Whether the listing ships free (parcel fee is 0). |
| `wish_count` | Number of users who wishlisted the listing. A real demand signal. |
| `chat_count` | Number of buyer chats opened on the listing. A real demand signal. |
| `url` | Listing page URL. |
| `image_url` | First product image (clean original asset). |
| `listed_at` | Listing sort/refresh time (KST, UTC+9). |
| `scraped_at` | ISO-8601 timestamp (KST, UTC+9). |

#### Known limitations (honest)

- **`region` is not available** from Joongna's search feed — the API returns an empty location for listing rows, so this field is always `null`. It is kept for schema compatibility only.
- **`category` name is not returned** on search rows. Use **category mode** with a `categorySeq` to scope results to a category instead of reading it off each row.
- **`status` does not vary** in practice: the search API only returns on-sale listings, so `status` is always `"selling"`. Reserved/sold listings are not exposed by this feed.

These fields are documented, not billed on — pricing reflects only the fields that reliably populate (name, price, image, wish/chat counts, free shipping, timestamps).

***

### Use cases

- **Secondhand price research** — track asking prices for sneakers, electronics, luxury goods, and K-pop goods across Korea's broadest secondhand marketplace.
- **Resale & arbitrage sourcing** — surface underpriced or high-demand listings (sort by newest or price, rank by `wish_count` / `chat_count`).
- **Demand analysis** — measure listing volume and engagement (wishlists, chats) for a product or category over time.
- **AI agents & datasets** — feed structured secondhand data into pricing models, sourcing dashboards, or LLM agents.

***

### ❓ FAQ

**Is it legal to scrape this data?**
This actor collects only public, non-personal catalog data — the same listings any visitor to web.joongna.com sees without logging in. No personal data is collected (no seller nicknames, ids, or profiles). You are responsible for how you use the data; see the legality note below.

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

**Do I need to configure proxies?**
No — the default settings work out of the box. For large runs or if you see repeated HTTP 403/429 errors, optionally enable Apify Proxy with the RESIDENTIAL group (see the proxy recommendation below).

**How fresh is the data?**
Every run scrapes the live site at run time. Schedule the actor for recurring snapshots.

**What is NOT included?**
No seller data of any kind (privacy by design), and no `region` or per-row `category` name — Joongna's search feed doesn't return them, so they are `null`. Only on-sale listings are exposed, so `status` is effectively always `"selling"`.

***

### 🇰🇷 More Korean data actors

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

- [bunjang-scraper](https://apify.com/kdatafactory/bunjang-scraper) — Bunjang (번개장터) secondhand marketplace listings.
- [encar-scraper](https://apify.com/kdatafactory/encar-scraper) — Encar used-car listings with prices and specs.
- [pocamarket-scraper](https://apify.com/kdatafactory/pocamarket-scraper) — K-pop photocard market prices from Pocamarket.

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 — no seller nicknames, store ids, profiles, or manner-temperature. Item, price, image, and public engagement data only.
- Requests are rate-limited: one page at a time with a ≥ 500 ms delay between requests, to stay gentle on Joongna's servers.
- You are responsible for using the data in line with Joongna's terms of service and applicable law.

#### ⚠️ Proxy recommendation

Joongna may block datacenter IPs or high request volumes. For reliable runs — especially at higher `maxItems` — enable **Apify Proxy with the `RESIDENTIAL` group**. The actor automatically uses the proxy configuration you provide (via `proxyConfiguration` in input) and, if a proxy tunnel fails, falls back to a direct connection rather than hanging. If you see repeated `API HTTP 403/429` errors in the log, switch on residential proxy.

***

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

# Actor input Schema

## `mode` (type: `string`):

What to scrape. 'search' returns listings matching a keyword. 'category' browses the newest/most-relevant listings in a Joongna category tree.

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

For 'search' mode: a keyword to search for (e.g. 'nike', '아이폰', 'jordan 1'). Required in search mode; optional in category mode to narrow the category listing.

## `categorySeq` (type: `integer`):

For 'category' mode: a Joongna top-level category seq (required). Examples: 1 Women's fashion, 2 Men's fashion, 6 Beauty, 8 Digital/Electronics, 10 Sports/Leisure, 21 Star goods (K-pop). Ignored in search mode.

## `order` (type: `string`):

Result ordering. 'score' = recommended/relevance, 'date' = newest first, 'price\_asc' = cheapest first, 'price\_dsc' = most expensive first.

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

Maximum number of listings to collect.

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

Proxy settings. Apify Proxy with the RESIDENTIAL group is recommended if you hit rate limits. If omitted, the actor runs on a direct connection.

## Actor input object example

```json
{
  "mode": "search",
  "query": "나이키",
  "categorySeq": 1,
  "order": "score",
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "query": "나이키",
    "categorySeq": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("kdatafactory/joongna-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 = {
    "query": "나이키",
    "categorySeq": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("kdatafactory/joongna-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 '{
  "query": "나이키",
  "categorySeq": 1
}' |
apify call kdatafactory/joongna-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Joongna Scraper: Korea Secondhand Marketplace (중고나라)",
        "description": "Scrape Joongna (중고나라), Korea's largest secondhand marketplace: keyword search and category browse for product names, KRW prices, images, wish/chat counts, and sale status as clean JSON. Powered by Joongna's search API. No seller identity collected.",
        "version": "0.1",
        "x-build-id": "HTlNuTpbij3YA38Ks"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/kdatafactory~joongna-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-kdatafactory-joongna-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/kdatafactory~joongna-scraper/runs": {
            "post": {
                "operationId": "runs-sync-kdatafactory-joongna-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/kdatafactory~joongna-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-kdatafactory-joongna-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "category"
                        ],
                        "type": "string",
                        "description": "What to scrape. 'search' returns listings matching a keyword. 'category' browses the newest/most-relevant listings in a Joongna category tree.",
                        "default": "search"
                    },
                    "query": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "For 'search' mode: a keyword to search for (e.g. 'nike', '아이폰', 'jordan 1'). Required in search mode; optional in category mode to narrow the category listing."
                    },
                    "categorySeq": {
                        "title": "Category ID",
                        "type": "integer",
                        "description": "For 'category' mode: a Joongna top-level category seq (required). Examples: 1 Women's fashion, 2 Men's fashion, 6 Beauty, 8 Digital/Electronics, 10 Sports/Leisure, 21 Star goods (K-pop). Ignored in search mode."
                    },
                    "order": {
                        "title": "Sort order",
                        "enum": [
                            "score",
                            "date",
                            "price_asc",
                            "price_dsc"
                        ],
                        "type": "string",
                        "description": "Result ordering. 'score' = recommended/relevance, 'date' = newest first, 'price_asc' = cheapest first, 'price_dsc' = most expensive first.",
                        "default": "score"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of listings to collect.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Apify Proxy with the RESIDENTIAL group is recommended if you hit rate limits. If omitted, the actor runs on a direct connection.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
