# Popply Scraper (Korean Pop-Up Stores: Schedules + Locations) (`kdatafactory/popply-scraper`) Actor

Scrape Korean pop-up store data from Popply (popply.co.kr) — the #1 pop-up aggregator. Returns each pop-up: name, brand, category, location (Seongsu, Hongdae, The Hyundai), start/end dates, status, image and URL. Event-based local retail intelligence. Privacy-safe: no personal data.

- **URL**: https://apify.com/kdatafactory/popply-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

## Popply Scraper — Korean Pop-Up Stores (Schedules, Brands & Locations)

Scrape **Korean pop-up store** data from [Popply](https://popply.co.kr) (팝플리) — Korea's #1 pop-up-store aggregator. Popply tracks the temporary, time-limited retail experiences that brands run across Seoul and Korea (Seongsu / 성수, Hongdae / 홍대, The Hyundai Seoul / 더현대, Gangnam, and beyond).

This actor turns that live calendar into a clean, structured dataset: for every pop-up it returns the **name, organizing brand, category, location, start/end dates, current status, image and URL**. It is the **event / time-limited complement** to a Naver Place or Google-Maps business scraper — instead of permanent shops, you get what's opening *this week* and *next*.

**Privacy-safe by construction:** only pop-up, venue and public brand data is collected. No personal names, nicknames, ids, profiles, phone numbers or reviewer/commenter identity — ever.

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

- Pulls the live pop-up list straight from Popply's public JSON backend (`api.popply.co.kr`) — fast and reliable, no headless browser needed.
- Merges the flat store list with Popply's curated "course" groups and **deduplicates** by pop-up id for maximum coverage.
- Maps each pop-up's numeric category to a human-readable label (Fashion, Beauty/Health, Food/Beverage, Character/IP, Goods, Exhibition, …).
- Normalizes status to `ongoing` (open now) or `upcoming` (scheduled).
- Optional **category / location / status filters** so you only pay for the rows you want.

### Input

All inputs are optional — run with no input to scrape every live pop-up.

| Field | Type | Description |
|-------|------|-------------|
| `category` | string | Keep only this category. English alias (`fashion`, `beauty`, `food`, `character`, `goods`, `exhibition`, …) or the Korean name (`패션`, `뷰티/헬스`, …). |
| `location` | string | Substring match on the pop-up's address / area, e.g. `성동` (Seongsu), `마포` (Hongdae), `강남`, `부산`. |
| `status` | select | `all` (default), `ongoing` (open now), or `upcoming` (scheduled). |
| `maxItems` | integer | Max pop-ups to scrape (default 200). |
| `proxyConfiguration` | proxy | Optional. The API is served to most IPs; a failed proxy tunnel auto-falls-back to a direct connection. |

#### Input example

```json
{
  "category": "fashion",
  "location": "성동",
  "status": "ongoing",
  "maxItems": 100
}
````

### Output

One record per pop-up store (real sample from a live run):

```json
{
  "source": "popply",
  "popup_id": "5475",
  "name": "타이니빌 팝업",
  "brand": "타이니빌",
  "category": "캐릭터/IP",
  "location": "경기 성남시",
  "address": "경기 성남시 분당구 판교역로146번길 20",
  "venue": "현대백화점 판교점 4층 아이코닉스퀘어",
  "latitude": 37.3927946,
  "longitude": 127.1120875,
  "start_date": "2026-07-10",
  "end_date": "2026-07-23",
  "status": "upcoming",
  "view_count": 5,
  "url": "https://popply.co.kr/popup/5475",
  "image_url": "https://d8nffddmkwqeq.cloudfront.net/store/f1786627%2C...",
  "scraped_at": "2026-07-09T13:33:15+09:00"
}
```

| Field | Notes |
|-------|-------|
| `source` | Always `"popply"`. |
| `popup_id` | Stable Popply store id. |
| `name` | Pop-up title. |
| `brand` | Organizing commercial brand (public info, like a shop name). |
| `category` | Human-readable Korean category label. |
| `location` | Coarse public area (e.g. `서울 성동구`). |
| `address` | Full street address of the venue. |
| `venue` | Venue / floor detail (e.g. department-store floor) when Popply provides it. |
| `latitude` / `longitude` | Map coordinates. |
| `start_date` / `end_date` | Run dates (`YYYY-MM-DD`). |
| `status` | `ongoing` or `upcoming`. |
| `view_count` | Popply page view count (aggregate; not personal). |
| `url` | Public pop-up page. |
| `image_url` | Cover image. |
| `scraped_at` | KST (UTC+9) ISO-8601 timestamp. |

The core fields (name, brand, category, location, dates, coordinates, status, url, image) populate on every record; `venue` is present for most but not all pop-ups (~80%), and the public feed only exposes ongoing/upcoming pop-ups (not `ended`) — see Known Limitations below and `samples/sample-output.json` for 40 real records.

### Use cases

- **Local retail intelligence** — track which brands are running pop-ups, where, and when. The event-based complement to permanent-store data.
- **Trend research** — pop-ups are where brands test drops before wide retail; combine with e-commerce actors (Musinsa, 29CM) for a full "what's launching in Korea" feed.
- **Location scouting / commercial real estate** — see which venues and neighborhoods (Seongsu, The Hyundai, Hongdae) host the most pop-ups.
- **Marketing & PR monitoring** — get alerted to competitor and IP/character (K-pop, gaming, anime) activations as they go live.
- **AI agents & apps** — a fresh, structured "pop-ups near me / this week" dataset for recommendation and event-discovery products.

### ❓ FAQ

**Is it legal to scrape this data?**
This actor collects only public, non-personal catalog data — the same pop-up listings any visitor sees on Popply without logging in. No personal data is collected. You are responsible for how you use the data; see the legality & privacy 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 very large or repeated runs, Apify Proxy (RESIDENTIAL, country KR) is an optional way to avoid rate limits; a failed proxy tunnel automatically falls back to a direct connection.

**How fresh is the data?**
Every run scrapes the live site at run time. Schedule the actor for recurring snapshots — pop-ups change weekly, so a scheduled run makes a great forward-looking calendar.

**What is NOT included?**
Historical / already-ended pop-ups (the public feed only lists ongoing and upcoming ones) and per-pop-up user reviews or comments (never collected, to avoid touching commenter identity). `venue` (floor detail) is present on ~80% of records.

### 🇰🇷 More Korean data actors

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

- [naver-place-scraper](https://apify.com/kdatafactory/naver-place-scraper) — Korean local businesses from Naver Place/Maps
- [tumblbug-scraper](https://apify.com/kdatafactory/tumblbug-scraper) — Korean crowdfunding projects, pledges and categories from Tumblbug

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

### Rate, legality & privacy

- **Public data only.** The actor reads the same public JSON endpoints Popply's own website calls to render its listing pages — no login, no private API.
- **Polite by default.** Requests are spaced ≥ 500 ms; a lite-test mode caps volume for validation.
- **No personal data.** Pop-up / venue / brand fields only. Reviewer and commenter identity is never touched. `brand` is a public commercial name, comparable to a shop name.
- **Proxy optional.** Popply's API answers most IPs directly. For very large or repeated runs, Apify Proxy (RESIDENTIAL, country KR) is recommended to avoid rate limits; a failed proxy tunnel automatically falls back to a direct connection.

### Known limitations

- Popply's public listing feed exposes **currently live and upcoming** pop-ups. Historical / already-ended pop-ups are not part of the standard feed, so `status: "ended"` rarely appears — treat this actor as a *forward-looking* calendar.
- `venue` (floor / sub-venue detail) is present for most but not all pop-ups (the rest carry the full street address only).
- Per-pop-up user reviews and comments are intentionally **not** collected (they would require reading commenter identity, which this actor never does).

***

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

# Actor input Schema

## `category` (type: `string`):

Optional. Keep only pop-ups in this category. Accepts the English category label or its Korean name — e.g. "fashion" / "패션", "beauty" / "뷰티/헬스", "food" / "푸드/음료", "character" / "캐릭터/IP", "goods" / "소품/굿즈", "exhibition" / "전시". Leave empty to scrape every category.

## `location` (type: `string`):

Optional. Keep only pop-ups whose address contains this text (substring match). Use a Korean area name as it appears in Popply, e.g. "성동" (Seongsu), "마포" (Hongdae/Mapo), "강남", "부산". Leave empty to scrape all locations.

## `status` (type: `string`):

Optional. Keep only pop-ups with this status. "ongoing" = currently open, "upcoming" = scheduled to open. Leave as "all" to include both.

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

Maximum number of pop-up stores to scrape.

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

Popply's public API is served to most IPs. A proxy is optional; if a proxy tunnel fails, the actor automatically falls back to a direct connection. RESIDENTIAL (country KR) is recommended only if you hit rate limits on large runs.

## Actor input object example

```json
{
  "category": "fashion",
  "location": "성동",
  "status": "all",
  "maxItems": 200,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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/popply-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/popply-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 '{}' |
apify call kdatafactory/popply-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Popply Scraper (Korean Pop-Up Stores: Schedules + Locations)",
        "description": "Scrape Korean pop-up store data from Popply (popply.co.kr) — the #1 pop-up aggregator. Returns each pop-up: name, brand, category, location (Seongsu, Hongdae, The Hyundai), start/end dates, status, image and URL. Event-based local retail intelligence. Privacy-safe: no personal data.",
        "version": "0.1",
        "x-build-id": "F4RPaucm6xA2f3NcB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/kdatafactory~popply-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-kdatafactory-popply-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~popply-scraper/runs": {
            "post": {
                "operationId": "runs-sync-kdatafactory-popply-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~popply-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-kdatafactory-popply-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",
                "properties": {
                    "category": {
                        "title": "Category filter",
                        "type": "string",
                        "description": "Optional. Keep only pop-ups in this category. Accepts the English category label or its Korean name — e.g. \"fashion\" / \"패션\", \"beauty\" / \"뷰티/헬스\", \"food\" / \"푸드/음료\", \"character\" / \"캐릭터/IP\", \"goods\" / \"소품/굿즈\", \"exhibition\" / \"전시\". Leave empty to scrape every category."
                    },
                    "location": {
                        "title": "Location filter",
                        "type": "string",
                        "description": "Optional. Keep only pop-ups whose address contains this text (substring match). Use a Korean area name as it appears in Popply, e.g. \"성동\" (Seongsu), \"마포\" (Hongdae/Mapo), \"강남\", \"부산\". Leave empty to scrape all locations."
                    },
                    "status": {
                        "title": "Status filter",
                        "enum": [
                            "all",
                            "ongoing",
                            "upcoming"
                        ],
                        "type": "string",
                        "description": "Optional. Keep only pop-ups with this status. \"ongoing\" = currently open, \"upcoming\" = scheduled to open. Leave as \"all\" to include both.",
                        "default": "all"
                    },
                    "maxItems": {
                        "title": "Max pop-ups",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Maximum number of pop-up stores to scrape.",
                        "default": 200
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Popply's public API is served to most IPs. A proxy is optional; if a proxy tunnel fails, the actor automatically falls back to a direct connection. RESIDENTIAL (country KR) is recommended only if you hit rate limits on large runs.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
