# 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
- **Stats:** 8 total users, 0 monthly users, 90.3% 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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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.

***

### 🤖 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. 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.

## `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.

## Actor input object example

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

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

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

Download the OpenAPI definition: https://api.apify.com/v2/acts/O9oZwHgf373OTTGEF/builds/3O2dYx5uiXHFm1meE/openapi.json