# Upbit Korean Crypto Exchange Scraper (`parseforge/upbit-market-scraper`) Actor

Scrape spot market data from Upbit, Korea's largest exchange. Market list, English/Korean names, market warnings, ticker prices, 24h volume in KRW/BTC. No API key required.

- **URL**: https://apify.com/parseforge/upbit-market-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Business, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $23.92 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🇰🇷 Upbit Korean Crypto Exchange Scraper

> 🚀 **Export the full Upbit market board in seconds.** Pull live ticker data, Korean and English coin names, market warnings, prices, and 24h KRW or BTC volume across **740+ trading pairs** on Korea's largest exchange. No API key, no signup, no localization headaches.

> 🕒 **Last updated:** 2026-05-13 · **📊 25 fields** per record · **🪙 740+ markets** · **🇰🇷 3 quote currencies (KRW, BTC, USDT)**

The **Upbit Market Scraper** queries Upbit's public market list and ticker endpoints and returns **25 fields per record**, including the market code, Korean and English coin names, market-warning flags, last trade price, opening price, 24h high and low, KRW or BTC volume, 52-week high and low, and timestamps. Upbit is the largest crypto exchange in South Korea by daily volume and serves as the primary on-ramp for the KRW market, which trades at a premium to global markets often called the "Kimchi premium."

The catalog covers **all live spot pairs on Upbit**, with KRW pairs forming the bulk of liquidity alongside smaller BTC- and USDT-quoted books. This Actor turns Upbit's split market and ticker endpoints into a single joined dataset with bilingual coin names and risk flags. Export it as CSV, Excel, JSON, or XML in under a minute. All filtering and sorting runs server-side.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Quant teams, Kimchi-premium analysts, KRW-market traders, fintech apps, research desks, Korean-market dashboards | Cross-border price spread monitoring, KRW premium tracking, market-warning detection, top-volume leaderboards, treasury reporting |

---

### 📋 What the Upbit Scraper does

Four filtering workflows in a single run:

- 🌐 **Full market snapshot.** Every live spot pair on Upbit, joined with bilingual metadata.
- 💱 **Quote filter.** Restrict to KRW (the dominant book), BTC, or USDT pairs.
- 📈 **Sort options.** Order by 24h quote volume, base volume, percent change, last price, or market code.
- 🚨 **Risk flags surfaced.** Market-warning and caution flags from Upbit's investor-protection rules are returned as first-class fields.

Each record includes the canonical market code (e.g. `KRW-BTC`), derived base and quote assets, Korean and English coin names, any active investor warnings (price fluctuations, volume surges, deposit-amount surges, global price differences, small-account concentration), last price, opening and previous-close prices, signed and absolute change values, 24h high/low, 24h quote and base volume, 52-week high and low with dates, and Upbit's trade timestamp converted to ISO 8601.

> 💡 **Why it matters:** Upbit's ticker data is split across two endpoints with no built-in pagination on the join, and the market-warning fields are nested two levels deep. Building your own pipeline means batching ticker calls 100 markets at a time, decoding Korean Unicode, and flattening nested caution objects. This Actor does all of it and ships clean records.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td><code>quoteCurrency</code></td><td>string</td><td><code>""</code></td><td>One of KRW, BTC, USDT. Empty = all markets.</td></tr>
<tr><td><code>sortBy</code></td><td>string</td><td><code>"accTradePrice24h"</code></td><td>Sort order: <code>accTradePrice24h</code>, <code>accTradeVolume24h</code>, <code>changeRate</code>, <code>tradePrice</code>, or <code>market</code>.</td></tr>
</tbody>
</table>

**Example: top 50 KRW pairs by 24h quote volume.**

```json
{
    "maxItems": 50,
    "quoteCurrency": "KRW",
    "sortBy": "accTradePrice24h"
}
````

**Example: every market, sorted by biggest 24h movers.**

```json
{
    "maxItems": 200,
    "quoteCurrency": "",
    "sortBy": "changeRate"
}
```

> ⚠️ **Good to Know:** Upbit uses the format `QUOTE-BASE` (e.g. `KRW-BTC`), the reverse of most Western exchanges. The Actor splits this so `baseAsset` is always the coin you are buying or selling and `quoteAsset` is the pricing currency. Market warnings come from Upbit's investor-protection program and are signals only, not trading bans.

***

### 📊 Output

Each market record contains up to **25 fields**. Optional warning fields appear only when active. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🏷️ `market` | string | `"KRW-BTC"` |
| 🔗 `url` | string | `"https://upbit.com/exchange?code=CRIX.UPBIT.KRW-BTC"` |
| 🪙 `baseAsset` | string | null | `"BTC"` |
| 💵 `quoteAsset` | string | null | `"KRW"` |
| 🇰🇷 `koreanName` | string | null | `"비트코인"` |
| 🇬🇧 `englishName` | string | null | `"Bitcoin"` |
| 🚨 `marketWarning` | string | null | `"CAUTION"` |
| ⚠️ `cautionFlags` | string\[] | `["DEPOSIT_AMOUNT_SOARING"]` |
| 💲 `tradePrice` | number | null | `117799000` |
| 🔓 `openingPrice` | number | null | `119202000` |
| 🔒 `prevClosingPrice` | number | null | `119202000` |
| 📉 `changeDirection` | string | null | `"FALL"` |
| 📊 `changePrice` | number | null | `1403000` |
| 📈 `changeRatePercent` | number | null | `1.176994` |
| ➕➖ `signedChangePrice` | number | null | `-1403000` |
| 📐 `signedChangeRatePercent` | number | null | `-1.176994` |
| ⬆️ `high24h` | number | null | `120339000` |
| ⬇️ `low24h` | number | null | `117300000` |
| 💰 `accTradePrice24h` | number | null | `177235358856.18` |
| 📦 `accTradeVolume24h` | number | null | `1488.097` |
| 🚀 `highest52WeekPrice` | number | null | `179869000` |
| 📅 `highest52WeekDate` | string | null | `"2025-10-09"` |
| 🪂 `lowest52WeekPrice` | number | null | `89000000` |
| 📅 `lowest52WeekDate` | string | null | `"2026-02-06"` |
| 🕒 `tradeTimestamp` | ISO 8601 | null | `"2026-05-13T16:37:33.609Z"` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-13T00:00:00.000Z"` |

#### 📦 Sample records

<details>
<summary><strong>🇰🇷 Bitcoin on the KRW book: KRW-BTC</strong></summary>

```json
{
    "market": "KRW-BTC",
    "url": "https://upbit.com/exchange?code=CRIX.UPBIT.KRW-BTC",
    "baseAsset": "BTC",
    "quoteAsset": "KRW",
    "koreanName": "비트코인",
    "englishName": "Bitcoin",
    "cautionFlags": [],
    "tradePrice": 117799000,
    "openingPrice": 119202000,
    "prevClosingPrice": 119202000,
    "changeDirection": "FALL",
    "changePrice": 1403000,
    "changeRatePercent": 1.176994,
    "signedChangePrice": -1403000,
    "signedChangeRatePercent": -1.176994,
    "high24h": 120339000,
    "low24h": 117300000,
    "accTradePrice24h": 177235358856.18,
    "accTradeVolume24h": 1488.097,
    "highest52WeekPrice": 179869000,
    "highest52WeekDate": "2025-10-09",
    "lowest52WeekPrice": 89000000,
    "lowest52WeekDate": "2026-02-06",
    "tradeTimestamp": "2026-05-13T16:37:33.609Z",
    "scrapedAt": "2026-05-13T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>⚠️ Ethereum with active deposit-surge flag: KRW-ETH</strong></summary>

```json
{
    "market": "KRW-ETH",
    "url": "https://upbit.com/exchange?code=CRIX.UPBIT.KRW-ETH",
    "baseAsset": "ETH",
    "quoteAsset": "KRW",
    "koreanName": "이더리움",
    "englishName": "Ethereum",
    "cautionFlags": ["DEPOSIT_AMOUNT_SOARING"],
    "tradePrice": 3352000,
    "openingPrice": 3374000,
    "prevClosingPrice": 3373000,
    "changeDirection": "FALL",
    "changePrice": 21000,
    "changeRatePercent": 0.622591,
    "signedChangePrice": -21000,
    "signedChangeRatePercent": -0.622591,
    "high24h": 3429000,
    "low24h": 3331000,
    "accTradePrice24h": 98950867474.06,
    "accTradeVolume24h": 29236.77,
    "highest52WeekPrice": 6845000,
    "highest52WeekDate": "2025-08-24",
    "lowest52WeekPrice": 2590000,
    "lowest52WeekDate": "2026-02-06",
    "tradeTimestamp": "2026-05-13T16:37:33.286Z",
    "scrapedAt": "2026-05-13T00:00:00.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🇰🇷 | **Korean market specialist.** 740+ markets covering Upbit's full KRW, BTC, and USDT order books. |
| 🌐 | **Bilingual names.** Both Korean and English coin names returned per record, no translation pass required. |
| 🚨 | **Investor protection signals.** Market warnings and caution flags surfaced as first-class fields. |
| 📊 | **Quote-volume sort.** Sort directly by 24h KRW (or BTC) volume to find the most liquid markets. |
| ⚡ | **Fast.** Full Upbit snapshot in under 20 seconds, with batched 100-market ticker fetches. |
| 🔁 | **Always fresh.** Every run pulls live data from Upbit's public API. |
| 🚫 | **No authentication.** Works with public endpoints. No API key, no IP whitelist. |

> 📊 The Kimchi premium is one of the most-watched anomalies in crypto. Clean Upbit data is the starting point for tracking it.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Bilingual names | Warnings | Setup |
|---|---|---|---|---|---|
| **⭐ Upbit Market Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **740+** markets | ✅ KO + EN | ✅ Built-in | ⚡ 2 min |
| Raw Upbit API | Free | All markets | Manual decode | Nested object | 🐢 Hours |
| Multi-venue aggregators | $50+/month | Many venues | Mixed | Rare | ⏳ Days |
| Static market-data dumps | Free | Stale | Inconsistent | None | 🕒 Variable |

Pick this Actor when you want the Upbit board ready to query without writing Korean-locale parsers.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the Upbit Korean Crypto Exchange Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick a quote currency (or leave empty for all), choose a sort order, set `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor pull the live market board.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 💱 Kimchi premium tracking

- Cross-venue spread monitoring vs Binance, Coinbase
- KRW premium dashboards for trading desks
- Historical premium series for academic research
- Alerting when premium crosses configurable thresholds

</td>
<td width="50%" valign="top">

#### 📈 KRW market trading

- Top-volume KRW pair leaderboards
- 24h gainer or loser screens for KRW traders
- Order-book hygiene checks via warning flags
- Treasury reporting in KRW units

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 🇰🇷 Korean fintech and apps

- Bilingual coin directories with English fallback
- Native Korean dashboards for retail investors
- Localized portfolio trackers for KRW residents
- Compliance feeds picking up Upbit warning flags

</td>
<td width="50%" valign="top">

#### 📊 Research and analytics

- 52-week high or low context for technical research
- Market-warning frequency analysis
- Liquidity distribution across KRW vs BTC books
- Cross-currency benchmarks for global studies

</td>
</tr>
</table>

***

### 🔌 Automating Upbit Market Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Minute-level snapshots feed live dashboards, hourly captures stack into time-series stores.

***

### 🌟 Beyond business use cases

Korean-market crypto data powers more than commercial workflows. The same structured records support research, journalism, and personal projects.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Cross-border crypto arbitrage studies
- Market-microstructure research on KRW books
- Investor-warning impact studies
- Reproducible datasets for finance coursework

</td>
<td width="50%">

#### 🎨 Personal and creative

- Bilingual portfolio trackers for Korea-based traders
- Hobbyist dashboards for KRW pair watchers
- Crypto-themed visualizations for content creators
- Open-source tools for the Korean dev community

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Consumer-protection journalism around warning flags
- Educational resources for retail investor literacy
- Open data for academic transparency efforts
- Audit support for Korean non-profit crypto holdings

</td>
<td width="50%">

#### 🧪 Experimentation

- Train ML models on Korean-market microstructure
- Test alerting agents that fire on warning flags
- Prototype Kimchi-premium calculators
- Validate UI translations against live data

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20Upbit%20Market%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20Upbit%20Market%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20Upbit%20Market%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20Upbit%20Market%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Pick a quote currency, sort order, and `maxItems`, click Start, and the Actor calls Upbit's `market/all` endpoint for the bilingual market metadata, then batches the matching market codes 100 at a time through the `ticker` endpoint. The two responses are joined and flattened into clean records.

#### 📏 How accurate is the data?

The data is the same feed Upbit serves to its trading UI. Prices reflect the moment of the run. For tick-by-tick precision schedule frequent runs.

#### 🔁 How often is the dataset refreshed?

Every run pulls live tickers. Schedule a run every minute, every hour, or every day depending on your downstream need.

#### 🛂 Do I need an Upbit account or API key?

No. This Actor only uses public market data endpoints, which require no authentication.

#### 🇰🇷 What is the Kimchi premium?

It is the price gap between Korean exchanges (typically Upbit) and global exchanges, often driven by capital controls, retail sentiment, and on-ramp friction. This Actor gives you the Upbit side of that comparison.

#### 🚨 What do the warning flags mean?

`marketWarning` is Upbit's top-level investor-warning status. `cautionFlags` is an array of granular signals: `PRICE_FLUCTUATIONS`, `TRADING_VOLUME_SOARING`, `DEPOSIT_AMOUNT_SOARING`, `GLOBAL_PRICE_DIFFERENCES`, `CONCENTRATION_OF_SMALL_ACCOUNTS`. These are investor-protection signals from Upbit, not trading bans.

#### ⏰ Can I schedule regular runs?

Yes. Apify Schedules supports any cron interval. A common pattern is one snapshot per minute into a time-series store.

#### ⚖️ Is this data legal to use?

Yes. Upbit publishes public market data under standard exchange terms. Review their terms of service for redistribution requirements.

#### 💼 Can I use this data commercially?

Yes. Public market data from a major exchange is widely used in commercial products. Confirm Upbit's API terms cover your specific use case if you plan to redistribute the raw feed.

#### 💳 Do I need a paid Apify plan to use this Actor?

No. The free Apify plan is enough for testing and small runs (10 records per run). A paid plan lifts the limit and unlocks scheduling and higher concurrency.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

Upbit Market Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Push warning-flag alerts into channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe Upbit data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes. Stream Kimchi-premium updates into a dashboard, or alert your team when a coin gets a new warning flag.

***

### 🔗 Recommended Actors

- [**📈 FINRA BrokerCheck Scraper**](https://apify.com/parseforge/finra-brokercheck-scraper) - U.S. broker and adviser registration records
- [**💼 Pitchbook Investors Scraper**](https://apify.com/parseforge/pitchbook-investors-scraper) - Private-market investor profiles
- [**💼 Pitchbook Funds Scraper**](https://apify.com/parseforge/pitchbook-funds-scraper) - PE and VC fund records
- [**🏪 Stripe Marketplace Scraper**](https://apify.com/parseforge/stripe-marketplace-scraper) - Fintech app marketplace catalog
- [**📰 PR Newswire Scraper**](https://apify.com/parseforge/pr-newswire-scraper) - Corporate and market press releases

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more financial and market-data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Upbit or Dunamu Inc. All trademarks mentioned are the property of their respective owners. Only publicly available market data is collected.

# Actor input Schema

## `quoteCurrency` (type: `string`):

Filter markets by quote currency. KRW = Korean Won pairs, BTC = Bitcoin-quoted pairs, USDT = Tether-quoted pairs. Leave empty for all.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `sortBy` (type: `string`):

Sort results by this field before applying maxItems

## Actor input object example

```json
{
  "quoteCurrency": "",
  "maxItems": 10,
  "sortBy": "accTradePrice24h"
}
```

# Actor output Schema

## `overview` (type: `string`):

Overview of scraped data

## `fullData` (type: `string`):

Complete 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 = {
    "quoteCurrency": "",
    "maxItems": 10,
    "sortBy": "accTradePrice24h"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/upbit-market-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 = {
    "quoteCurrency": "",
    "maxItems": 10,
    "sortBy": "accTradePrice24h",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/upbit-market-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 '{
  "quoteCurrency": "",
  "maxItems": 10,
  "sortBy": "accTradePrice24h"
}' |
apify call parseforge/upbit-market-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Upbit Korean Crypto Exchange Scraper",
        "description": "Scrape spot market data from Upbit, Korea's largest exchange. Market list, English/Korean names, market warnings, ticker prices, 24h volume in KRW/BTC. No API key required.",
        "version": "0.0",
        "x-build-id": "eLtg4EVSIdeMhGbEJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~upbit-market-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-upbit-market-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/parseforge~upbit-market-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-upbit-market-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/parseforge~upbit-market-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-upbit-market-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": {
                    "quoteCurrency": {
                        "title": "Quote Currency Filter",
                        "enum": [
                            "",
                            "KRW",
                            "BTC",
                            "USDT"
                        ],
                        "type": "string",
                        "description": "Filter markets by quote currency. KRW = Korean Won pairs, BTC = Bitcoin-quoted pairs, USDT = Tether-quoted pairs. Leave empty for all.",
                        "default": ""
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "accTradePrice24h",
                            "accTradeVolume24h",
                            "changeRate",
                            "tradePrice",
                            "market"
                        ],
                        "type": "string",
                        "description": "Sort results by this field before applying maxItems",
                        "default": "accTradePrice24h"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
