# Encar Scraper — Korean Used Car Listings & Export Market Data (`kdatafactory/encar-scraper`) Actor

Scrape Encar, Korea's #1 used-car marketplace (~158k live listings): make, model, trim, year, KRW price, mileage, fuel and region as clean JSON. Built on Encar's own JSON API for speed. For used-car export sourcing, price analytics, and market research.

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

## Encar Used-Car Scraper 🚗

Scrape live **used-car listings** from [Encar](https://www.encar.com) — Korea's #1 used-car marketplace (~150k+ active listings) — as clean, structured JSON. Get make, model, trim, year, price (KRW), mileage, fuel type, and region for every vehicle in one run.

Built for **used-car export sourcing**, **price & depreciation analytics**, and **Korean automotive market research**.

> **Try it free.** Apify's free plan includes $5 of monthly platform credit — roughly **2,500 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 Encar's public listing search JSON API (the same one that powers encar.com), so results are fast and complete — no fragile HTML scraping. You can scrape:

- **The whole marketplace** (domestic, imported, or both), or
- **A specific make** (e.g. Hyundai, Genesis, Mercedes-Benz), or
- **A specific make + model group** (e.g. Kia → K5).

Results can be sorted by newest listed, price, mileage, or year.

> **Why Encar?** Korea is one of the largest used-car **export** markets in the world. International dealers and exporters use Encar as their primary sourcing feed — this actor turns that feed into a structured dataset you can filter, price-model, and pipe into your own tools.

---

### Input

| Field | Type | Description |
|-------|------|-------------|
| `carType` | string | `"all"`, `"domestic"` (Korean brands), or `"imported"`. Default `all`. |
| `manufacturer` | string | Optional make filter, in Encar's Korean label, e.g. `현대` (Hyundai), `기아` (Kia), `제네시스` (Genesis), `벤츠` (Mercedes-Benz), `BMW`, `테슬라` (Tesla). Blank = all makes. |
| `modelGroup` | string | Optional model-group filter (requires `manufacturer`), e.g. `그랜저`, `K5`, `아반떼`. Blank = all models. |
| `sort` | string | `newest`, `price_asc`, `price_desc`, `mileage_asc`, or `year_desc`. Default `newest`. |
| `maxItems` | integer | Max listings to collect. Default `100`, max `10000`. |
| `proxyConfiguration` | object | Proxy settings (see below). |

#### Input example

```json
{
  "carType": "all",
  "manufacturer": "현대",
  "modelGroup": "그랜저",
  "sort": "price_asc",
  "maxItems": 200
}
````

```json
{
  "carType": "imported",
  "sort": "newest",
  "maxItems": 500
}
```

***

### Output

Each vehicle listing is one dataset record. `price_krw` is the full price in Korean won (Encar shows prices in 만원 / 10,000-won units — this actor converts them to plain KRW). `mileage_km` is in kilometres. `region` is the coarse city/province where the car is listed.

```json
{
  "source": "encar",
  "listing_id": "41635144",
  "make": "쉐보레(GM대우)",
  "make_en": "Chevrolet",
  "model": "올 뉴 말리부",
  "trim": "1.5 터보 LS",
  "year": 2017,
  "price_krw": 5600000,
  "mileage_km": 134086,
  "fuel": "가솔린",
  "sell_type": "일반",
  "region": "경기",
  "url": "https://fem.encar.com/cars/detail/41635144",
  "image_url": "https://ci.encar.com/carpicture02/pic4162/41625787_001.jpg",
  "scraped_at": "2026-07-09T13:16:52+09:00"
}
```

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

| Field | Meaning |
|-------|---------|
| `source` | Always `"encar"`. |
| `listing_id` | Encar vehicle listing id. |
| `make` | Manufacturer, as Encar labels it (Korean). |
| `make_en` | English make name for common brands, else `null`. |
| `model` | Model name. |
| `trim` | Trim / badge (e.g. `1.5 터보 LS`), else `null`. |
| `year` | Model year (4-digit). |
| `price_krw` | Asking price in KRW. |
| `mileage_km` | Odometer reading in km. |
| `fuel` | Fuel type (가솔린 = petrol, 디젤 = diesel, 전기 = electric, etc.). |
| `sell_type` | Listing type (일반 = standard, 리스승계 = lease transfer, etc.). |
| `region` | Coarse listing region (province/city). |
| `url` | Listing detail page URL. |
| `image_url` | Main photo URL. |
| `scraped_at` | ISO-8601 timestamp (KST, UTC+9). |

***

### Use cases

- **Used-car export sourcing** — build a live, filterable catalogue of Korean used cars (with photos, price, mileage, and year) to source vehicles for export to your market.
- **Price & depreciation analytics** — track `price_krw` against year, mileage, make, and model to model residual values and spot underpriced listings.
- **Market & inventory research** — measure supply by brand, fuel type (including the surging EV share), and region across ~150k+ listings.
- **AI agents & datasets** — feed structured used-car data into pricing models, dashboards, or LLM agents.

***

### ❓ FAQ

**Is it legal to scrape this data?**
This actor collects only public, non-personal listing data — the same used-car listings any visitor sees on encar.com without logging in. No personal or dealer data is collected. You are responsible for how you use the data; see the legality note below.

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

**Do I need to configure proxies?**
No — the default settings work out of the box. For heavy pulls (high `maxItems`), enabling Apify Proxy with the `RESIDENTIAL` group is recommended as optional scaling advice — see the proxy note below.

**How fresh is the data?**
Every run scrapes the live Encar site at run time. Schedule the actor for recurring snapshots (e.g. daily price tracking).

**What is NOT included?**
Transmission is not included (it only exists on the per-vehicle detail endpoint, which carries dealer PII we deliberately don't fetch). Make/model/fuel/region come as Korean strings, with a `make_en` convenience field for common brands.

***

### 🇰🇷 More Korean data actors

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

- [joongna-scraper](https://apify.com/kdatafactory/joongna-scraper) — secondhand-goods listings from Joongna, Korea's largest used-goods market.
- [bunjang-scraper](https://apify.com/kdatafactory/bunjang-scraper) — live product listings from Bunjang, Korea's top C2C resale app.

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 / dealer data** is collected. This actor deliberately does **not** fetch Encar's per-vehicle detail endpoint, which carries dealer names, user ids, and phone numbers. Only vehicle attributes and a coarse listing region are returned.
- Requests are rate-limited: one page at a time with a ≥ 500 ms delay between requests, to stay gentle on Encar's servers.
- You are responsible for using the data in line with Encar's terms of service and applicable law.

#### Known limitations (honesty note)

- **Transmission** is not included. It is only available on the per-vehicle detail endpoint, and that endpoint also exposes dealer PII — so, per our privacy rules, we don't fetch it. Every field listed above is collected from the public list API and populates reliably (verified in a live test: 36/36 records fully populated, `trim`/`year`/`price`/`mileage`/`fuel`/`region` all 100%).
- **Make/model/fuel/region are Korean strings** (a `make_en` convenience field is provided for common brands). Model and trim are not translated.

#### ⚠️ Proxy recommendation

Encar 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 `proxyConfiguration` you provide and runs direct when none is set. 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/encar-scraper) helps a solo maintainer a lot. Found an issue? Open it in the Issues tab — I respond fast.*

# Actor input Schema

## `carType` (type: `string`):

Which vehicle pool to scrape. 'domestic' = Korean-brand cars (Hyundai, Kia, Genesis...). 'imported' = imported brands (Mercedes-Benz, BMW, Toyota...). 'all' = both.

## `manufacturer` (type: `string`):

Optional filter by manufacturer name as Encar labels it in Korean, e.g. '현대' (Hyundai), '기아' (Kia), '제네시스' (Genesis), '벤츠' (Mercedes-Benz), 'BMW', '아우디' (Audi), '테슬라' (Tesla). Leave blank for all makes.

## `modelGroup` (type: `string`):

Optional model-group filter, requires manufacturer to be set. Encar's Korean model-group label, e.g. '그랜저', 'K5', '아반떼'. Leave blank for all models of the chosen make.

## `sort` (type: `string`):

How to order the listing feed before collecting.

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

Maximum number of vehicle listings to collect.

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

Proxy settings. Encar may block datacenter IPs at higher volumes — Apify Proxy with the RESIDENTIAL group is recommended. Runs direct when omitted.

## Actor input object example

```json
{
  "carType": "all",
  "manufacturer": "",
  "modelGroup": "",
  "sort": "newest",
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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/encar-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/encar-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/encar-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Encar Scraper — Korean Used Car Listings & Export Market Data",
        "description": "Scrape Encar, Korea's #1 used-car marketplace (~158k live listings): make, model, trim, year, KRW price, mileage, fuel and region as clean JSON. Built on Encar's own JSON API for speed. For used-car export sourcing, price analytics, and market research.",
        "version": "0.1",
        "x-build-id": "jXbLn8EoqKa7k3yPc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/kdatafactory~encar-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-kdatafactory-encar-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~encar-scraper/runs": {
            "post": {
                "operationId": "runs-sync-kdatafactory-encar-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~encar-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-kdatafactory-encar-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": {
                    "carType": {
                        "title": "Car origin",
                        "enum": [
                            "all",
                            "domestic",
                            "imported"
                        ],
                        "type": "string",
                        "description": "Which vehicle pool to scrape. 'domestic' = Korean-brand cars (Hyundai, Kia, Genesis...). 'imported' = imported brands (Mercedes-Benz, BMW, Toyota...). 'all' = both.",
                        "default": "all"
                    },
                    "manufacturer": {
                        "title": "Manufacturer (make)",
                        "type": "string",
                        "description": "Optional filter by manufacturer name as Encar labels it in Korean, e.g. '현대' (Hyundai), '기아' (Kia), '제네시스' (Genesis), '벤츠' (Mercedes-Benz), 'BMW', '아우디' (Audi), '테슬라' (Tesla). Leave blank for all makes.",
                        "default": ""
                    },
                    "modelGroup": {
                        "title": "Model group",
                        "type": "string",
                        "description": "Optional model-group filter, requires manufacturer to be set. Encar's Korean model-group label, e.g. '그랜저', 'K5', '아반떼'. Leave blank for all models of the chosen make.",
                        "default": ""
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "newest",
                            "price_asc",
                            "price_desc",
                            "mileage_asc",
                            "year_desc"
                        ],
                        "type": "string",
                        "description": "How to order the listing feed before collecting.",
                        "default": "newest"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of vehicle listings to collect.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Encar may block datacenter IPs at higher volumes — Apify Proxy with the RESIDENTIAL group is recommended. Runs direct when omitted.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```