# Encar Scraper - Korean Used Car Export Data API (`kdatafactory/encar-scraper`) Actor

Live Korean used-car listings from Encar.com as clean English JSON: make, model, year, mileage, price, VIN & spec. Built for used-car exporters & dealers sourcing Korean inventory at scale (CIS, Mongolia, Middle East, Africa).

- **URL**: https://apify.com/kdatafactory/encar-scraper.md
- **Developed by:** [Seok June Park](https://apify.com/kdatafactory) (community)
- **Categories:** E-commerce, Developer tools
- **Features:** Limited permissions
- **Stats:** 30 total users, 3 monthly users, 89.6% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## 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 **1,000 results** from this actor, no credit card required. Set your input, click Start, and export JSON/CSV/Excel.

***

### What it does

This actor pulls listing data directly from 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. Encar's Korean label, e.g. `현대`, `기아`, `제네시스`, `쉐보레(GM대우)`, `르노코리아(삼성)`, `KG모빌리티(쌍용)`, `벤츠`, `BMW`, `도요타`, `테슬라` — or an English / short name (`Hyundai`, `Kia`, `Chevrolet`, `Mercedes-Benz`, `Toyota`, `SsangYong`…), which is resolved to Encar's label. Blank = all makes. |
| `modelGroup` | string | Optional model-group filter, e.g. `그랜저`, `K5`, `아반떼`, `5시리즈`, `E-클래스`. Works on its own, but set `manufacturer` too: then common English names (`Grandeur`, `Santa Fe`, `5 Series`, `E-Class`…) are matched against Encar's live model-group list. Blank = all models. |
| `sort` | string | `newest`, `price_asc`, `price_desc`, `mileage_asc`, or `year_desc`. Default `newest`. |
| `salesOnly` | boolean | Exclude lease/rent takeovers (see below). Recommended for price sorts and price statistics. Default `false`. |
| `maxItems` | integer | Max listings to collect. Default `100` (the Console form pre-fills `10` for a cheap first run), max `10000`. Encar serves at most the first 10,000 results of one search — split larger jobs by `carType` / `manufacturer` / `modelGroup`. |
| `includeVinSpec` | boolean | Add VIN + full spec from each listing's public detail record (one extra request per vehicle, billed separately only when the VIN arrives). Default `false`. |
| `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": "올 뉴 말리부",
  "model_group": "말리부",
  "model_group_en": "Malibu",
  "trim": "1.5 터보 LS",
  "year": 2017,
  "price_krw": 5600000,
  "is_lease_takeover": false,
  "monthly_payment_krw": null,
  "lease_months_remaining": null,
  "mileage_km": 134086,
  "fuel": "가솔린",
  "fuel_en": "Gasoline",
  "sell_type": "일반",
  "region": "경기",
  "region_en": "Gyeonggi",
  "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 / generation name as Encar shows it (Korean, e.g. `쏘나타 디 엣지(DN8)`). |
| `model_group` | Model family the listing belongs to (e.g. `쏘나타`), else `null`. |
| `model_group_en` | **Encar's own English name** for that model family (e.g. `Sonata`, `Grandeur`, `5-Series`), else `null`. Matched on 99.8% of 478 live listings (2026-11-10). |
| `trim` | Trim / badge (e.g. `1.5 터보 LS`), else `null`. |
| `year` | Model year (4-digit). |
| `price_krw` | Asking price in KRW. **`null` on lease/rent takeovers** — see below. |
| `is_lease_takeover` | `true` when the listing hands over a lease/rent contract instead of selling the car. |
| `monthly_payment_krw` | Monthly lease/rent payment in KRW, else `null`. |
| `lease_months_remaining` | Months left on the contract, else `null`. |
| `mileage_km` | Odometer reading in km. |
| `fuel` | Fuel type as Encar labels it (Korean). |
| `fuel_en` | Fuel in English: `Gasoline`, `Diesel`, `LPG`, `Hybrid`, `Electric`, `Hydrogen`, `Gasoline/LPG`, `Gasoline/CNG`, `CNG` or `Other`. |
| `sell_type` | Listing type: 일반 = standard sale, 리스 = lease takeover, 렌트 = rent takeover. |
| `region` | Coarse listing region (province/city), in Korean. |
| `region_en` | Region in English (e.g. `Seoul`, `Gyeonggi`, `Busan`, `Jeonnam/Gwangju`). |
| `url` | Listing detail page URL. |
| `image_url` | Main photo URL. |
| `scraped_at` | ISO-8601 timestamp (KST, UTC+9). |

#### Lease & rent takeovers (why `price_krw` can be `null`)

About **3.5% of Encar listings** (measured live: 210,951 total vs 203,503 `SellType.일반`; higher on newer EVs) are 리스 / 렌트 takeovers: you assume someone's existing lease or rental contract rather than buying the car. Encar's own headline figure for these is the **monthly payment**, not a sale price, and the list feed's price field carries a fine-print "차량가격" that is not comparable to a sale price — e.g. rent takeover [42477171](https://fem.encar.com/cars/detail/42477171) lists 차량가격 780만원 on a Model Y whose contract actually totals 3,900만원 (월 65만원 × 60개월).

Dropping that number into a price column would quietly poison any average, so these listings are kept but **flagged**: `price_krw` is `null`, `is_lease_takeover` is `true`, and the real contract terms land in `monthly_payment_krw` and `lease_months_remaining`.

> **Sorting by price?** Because takeovers carry no sale price they sort to the very front of `price_asc`, so a small run can come back with *every* `price_krw` null. Set **`salesOnly: true`** to exclude them at the source (verified: `price_asc` goes from 20/20 null prices to 0/20).

```json
{
  "listing_id": "42275761",
  "make": "테슬라",
  "model": "모델 3",
  "trim": "스탠다드 RWD",
  "year": 2026,
  "price_krw": null,
  "is_lease_takeover": true,
  "monthly_payment_krw": 620000,
  "lease_months_remaining": 55,
  "sell_type": "리스"
}
```

Filter with `is_lease_takeover == false` for a clean sale-price dataset, or `== true` to analyse the lease-transfer market on its own.

***

### 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?**
$5.00 per 1,000 results + a few cents of platform usage. Example: a 500-result daily pull costs about $2.50/day. Apify's free $5 monthly credit covers ~1,000 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, colour, displacement and VIN are not in the base listing feed; turn on `includeVinSpec` to add them from each vehicle's public detail record (vehicle attributes only — dealer contact data is never read). Make, model family, fuel and region also come in English (`make_en`, `model_group_en`, `fuel_en`, `region_en`); the model-family names are Encar's own. The generation name (`model`) and `trim` stay in Korean.

**My search returned no rows — is the actor broken?**
No. When a filter matches nothing the run still finishes successfully, and its **status message** says why — for example that a make name is not one of Encar's labels (with the list of valid labels and live counts), that a model group has no live listings, or that `carType` excludes the make you asked for. If a make or model name only differs from Encar's label by language, spelling or spacing (`Hyundai`, `Grandeur`, `아이오닉 5`), the actor corrects it and says so in the status message.

**What do the error messages mean?**
A failed run states what Encar actually answered and whether a proxy can help: HTTP 403/429 is a genuine block or rate limit (a RESIDENTIAL proxy, ideally with country `KR`, helps); HTTP 400 is a rejected query and HTTP 404 a moved endpoint (a proxy does not help — please report the run); an empty HTTP 200 is a request rejected at the CDN edge (a proxy does not help). A failure on a later page keeps every row already collected.

***

### 🤖 Use with AI agents (MCP)

Call this Actor as a tool from Claude or any MCP-compatible AI agent — no glue code. Point your MCP client at Apify's server, scoped to this Actor:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=kdatafactory/encar-scraper",
      "headers": { "Authorization": "Bearer <YOUR_APIFY_TOKEN>" }
    }
  }
}
```

Your agent can then pull Encar used-car listings and export-market data on demand — no scraping code in your app. Grab a free token from [Apify → Integrations](https://console.apify.com/settings/integrations).

### 🇰🇷 More Korean data actors

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

- [kbchachacha-scraper](https://apify.com/kdatafactory/kbchachacha-scraper) — **KB Chachacha used cars** — pair with Encar for full used-car export sourcing.
- [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. Encar's per-vehicle detail endpoint (which also carries dealer names, user ids and phone numbers) is called only when `includeVinSpec` is on, and only its vehicle attributes are read. Only vehicle attributes and a coarse listing region are returned.
- Requests are rate-limited: one request at a time, at least 1 second apart, 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 in the base feed; it comes with `includeVinSpec` (see above). Every base 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%).
- **10,000 results per search.** Encar's search serves only the first 10,000 results of any one query; a larger `maxItems` stops there and the status message says so. Split big pulls by `carType`, `manufacturer` or `modelGroup`.
- **"Price on inquiry" listings** carry Encar's 99,999만원 sentinel, i.e. `price_krw` 999,990,000, and sort to the top of `price_desc`.
- **English fields:** `make_en`, `model_group_en` (Encar's own English model-family names), `fuel_en` and `region_en`. The generation name (`model`, e.g. `쏘나타 디 엣지(DN8)`) and `trim` are not translated, because Encar publishes no English name at that level and we do not machine-translate.

#### ⚠️ 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.*

***

### ⭐ Found it useful?

If this Actor saves you time, a short review on its Apify Store page helps other buyers find it. Missing a field or hit a bug? Open an issue on the **Issues** tab; reports are answered and fixed.

# 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 make filter. Encar labels makes in Korean — e.g. '현대', '기아', '제네시스', '쉐보레(GM대우)', '르노코리아(삼성)', 'KG모빌리티(쌍용)', '벤츠', 'BMW', '아우디', '도요타', '테슬라' — and English or short names are accepted too ('Hyundai', 'Kia', 'Chevrolet', 'Mercedes-Benz', 'Toyota', 'SsangYong'...). If nothing matches, the run ends with a status message listing Encar's valid make labels with live counts. Leave blank for all makes.

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

Optional model-group filter, in Encar's Korean label, e.g. '그랜저', 'K5', '아반떼', '5시리즈', 'E-클래스'. Works best together with manufacturer: then common English names ('Grandeur', 'Sonata', 'Santa Fe', '5 Series', 'E-Class'...) are matched against Encar's live model-group list, and a value that matches nothing ends the run with a status message listing the valid model groups for that make. Leave blank for all models.

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

How to order the listing feed before collecting.

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

Maximum number of vehicle listings to collect. Encar serves at most the first 10,000 results of any single search, so for more than that split the job by carType / manufacturer / modelGroup.

## `includeVinSpec` (type: `boolean`):

If enabled, each listing is enriched from its public detail record with VIN, full spec (displacement, transmission, colour, seats, body type), English grade name, new-car price, and option/photo counts. Adds one request per vehicle (higher cost/time). Dealer personal info (contact, name, plate number) is never collected.

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

Proxy settings. Encar intermittently blocks datacenter IPs, so this defaults to Apify Proxy with the RESIDENTIAL group for reliability. You can switch to datacenter to cut cost if blocks aren't an issue for your volume. Runs direct when the whole object is cleared.

## `salesOnly` (type: `boolean`):

Return only standard sales (SellType 일반). About 3.5% of Encar listings are 리스/렌트 takeovers whose headline figure is a MONTHLY payment, not a sale price, so their price_krw is null. They sort to the very front of a price-ascending run, which can make an entire page priceless — turn this on whenever you sort by price or compute price statistics.

## Actor input object example

```json
{
  "carType": "all",
  "manufacturer": "",
  "modelGroup": "",
  "sort": "newest",
  "maxItems": 10,
  "includeVinSpec": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "salesOnly": false
}
```

# Actor output Schema

## `results` (type: `string`):

Every record collected in this run.

# 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 = {
    "carType": "all",
    "sort": "newest",
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// 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 = {
    "carType": "all",
    "sort": "newest",
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# 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(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "carType": "all",
  "sort": "newest",
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call kdatafactory/encar-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,kdatafactory/encar-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/O9oZwHgf373OTTGEF/builds/sfURldC82hXQj5q3F/openapi.json