# Encar Used Car Listings Scraper (`automation-lab/encar-used-car-listings-scraper`) Actor

Export Encar used car listings from public search-page snapshots with Korean vehicle names, year, mileage, source asking prices and region for sourcing and downstream comparison.

- **URL**: https://apify.com/automation-lab/encar-used-car-listings-scraper.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 50.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.40 / 1,000 vehicle listings

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

Export **Encar used car listings** from public first-page search snapshots for Korean vehicle sourcing and asking-price comparisons. Supply Encar search URLs and receive unique vehicle IDs, source links, Korean model and trim names, registration/model years, mileage, raw asking-price values and regions.

This Actor collects only records exposed in each page's embedded search response. It does **not** crawl the full inventory, fetch vehicle details or maintain history. Use scheduled runs and your own database to compare snapshots over time.

### Who is it for?

- Vehicle sourcing teams reviewing publicly advertised Korean stock.
- Automotive analysts comparing mileage, model year and source asking-price values.
- Data teams joining repeated exports by stable Encar vehicle ID.

### Why use this Actor?

The output distinguishes registration YYYYMM from model year, preserves Korean vehicle labels, and removes duplicate IDs across normal and promoted search sections and across input URLs. It retains the original search URL so downstream analysts can trace the selection.

There is no browser or proxy configuration to tune. The Actor reads anonymous search-page state through Apify's automatic datacenter proxy selection for the running account (no private named group required) and fails visibly if the expected state or filter expression is missing. Residential proxies and browser fallbacks are not enabled. This is a bounded snapshot tool, not a completeness guarantee.

### Get started

1. Open a public Encar vehicle search on `car.encar.com/list/car`.
2. Copy its first-page URL. The URL must use HTTPS and the supported `search` JSON described below.
3. Enter one to five URL objects under `startUrls`, or omit the field to try the domestic-car example.
4. Set `maxItems` (100 by default).
5. Run and inspect the default dataset. Download JSON, CSV, Excel or other dataset formats through Apify.

The smallest example is:

```json
{"maxItems": 100}
```

An explicit domestic-car search:

```json
{
  "startUrls": [{
    "url": "https://car.encar.com/list/car?page=1&search=%7B%22type%22%3A%22car%22%2C%22action%22%3A%22(And.Hidden.N._.CarType.Y.)%22%7D"
  }],
  "maxItems": 100
}
```

### Input parameters

| Field | Behavior |
|---|---|
| `startUrls` | Array of 1–5 objects containing `url` only. Omitted: domestic-car example. An empty array is invalid. |
| `maxItems` | Global unique-ID output cap, 1–1000 inclusive; default 100 when omitted; Console prefill 20 for a small first run. Zero/unlimited is unsupported. |

Only `https://car.encar.com/list/car` is supported. The URL may have one `page` parameter, which must be `1`, and one `search` parameter. Search JSON must have `type: "car"` and a nonempty Encar `action` string up to 2000 characters. An optional `sort: "MobileModifiedDate"` is accepted, including when Encar adds it during redirection. Other search keys, sorting modes, URL parameters, fragments, credentials, ports, hosts and detail URLs are rejected rather than silently ignored.

Filters are interpreted by Encar, not by an Actor-side text matcher. The Actor verifies that returned search state uses the exact requested action expression. It does not build filter expressions, translate labels or apply additional local model/price filters. Domestic and imported-car actions were verified; arbitrary source filter semantics are not independently guaranteed.

### What data is returned?

| Field | Meaning |
|---|---|
| `vehicleId`, `url` | Vehicle ID and canonical Encar detail link; details are not fetched. |
| `sourceUrl` | Original input search URL. |
| `manufacturer`, `model`, `modelGroup` | Source vehicle labels, normally Korean. |
| `trim`, `trimDetail` | Source Badge and BadgeDetail labels. |
| `registrationYearMonth` | Unmodified numeric Year value, normally YYYYMM. |
| `modelYear` | Numeric FormYear; distinct from registration date. |
| `mileageKm` | Source mileage in kilometres. |
| `askingPriceSource` | Raw, unscaled source Price number. |
| `priceUnit` | Always null: price scaling has not been independently verified. |
| `region` | Source OfficeCityState label, not a seller street address. |
| `fuel`, `transmission` | Source text labels. |
| `scrapedAt` | UTC extraction timestamp, not source listing-update time. |

Optional unavailable attributes are null. Identity and model must be present; malformed records cause a visible failure rather than a misleading incomplete export.

### Example output

This representative record illustrates the current source shape; values change as inventory changes:

```json
{
  "vehicleId": "42563709",
  "url": "https://fem.encar.com/cars/detail/42563709",
  "sourceUrl": "https://car.encar.com/list/car?page=1&search=%7B%22type%22%3A%22car%22%2C%22action%22%3A%22(And.Hidden.N._.CarType.Y.)%22%7D",
  "manufacturer": "제네시스",
  "model": "G80",
  "modelGroup": "G80",
  "trim": "3.3 GDI AWD",
  "trimDetail": "프리미엄 럭셔리",
  "registrationYearMonth": 201610,
  "modelYear": 2017,
  "mileageKm": 114719,
  "askingPriceSource": 1350,
  "priceUnit": null,
  "region": "경기",
  "fuel": "가솔린",
  "transmission": "오토",
  "scrapedAt": "2026-10-28T07:11:49.731Z"
}
```

Do not interpret `1350` as 1,350 KRW. The Actor deliberately does not multiply prices or label them as converted currency. Confirm the source's displayed price convention before performing monetary comparisons.

### Coverage, ordering and limits

Normal search results are read first, followed by available premium and preferential sections. At verification time these exposed 200, 10 and 40 rows respectively. Those are observations, not guaranteed upstream limits. Duplicate IDs retain the first encountered record.

URLs are processed sequentially. `maxItems` applies after deduplication across the entire run; later URLs are not fetched once the cap is reached. If snapshots expose fewer matching unique rows, the dataset is smaller than the cap. Source match-count totals do not mean all those listings were collected. There is no automatic pagination and no exhaustive-inventory promise.

The Actor bounds transport retries and same-host redirects. It retries transient network faults, 429 and 5xx responses, but does not blindly retry permanent blocks. An unavailable page or changed state fails the run; a recognized fulfilled zero-match search may succeed with zero rows. If a later URL fails, earlier dataset rows remain partial and the failed run must not be treated as a complete export.

### How much does it cost to export Encar used car listings?

Pay-per-event pricing consists of one **$0.005 start event per valid run**, plus an item event for each saved unique listing. Invalid input is rejected before the start event. Empty valid searches still incur the start event. Rejected or duplicate records have no item charge.

| Apify tier | Per listing |
|---|---:|
| FREE | $0.0046 |
| BRONZE | $0.004 |
| SILVER | $0.00312 |
| GOLD | $0.0024 |
| PLATINUM | $0.0024 |
| DIAMOND | $0.0024 |

Example total run invoices, including the start event: BRONZE n=1 → $0.009; n=25 → $0.105; n=100 → $0.405. FREE n=100 → $0.465. This Actor adds no separate detail, history, photo or contact charges. Check the active pricing panel before running; platform limits and your account conditions still apply. A billing budget stop can yield fewer records than the requested collection cap.

### Integrations and recurring comparisons

Schedule repeated runs with the same search input, export the default dataset and store each extraction timestamp. Join on `vehicleId` to compare observed price values, mileage or presence between snapshots. Absence from a bounded snapshot does not prove a vehicle was sold or removed.

Send rows to Google Sheets for sourcing review, a warehouse for cohort analysis, or an Apify webhook workflow for downstream processing. The Actor itself does not send alerts, maintain a previous-run cache, detect changes or perform export transactions.

### API examples

Use an Apify API token through your environment, never in a public URL.

#### cURL

```bash
curl -X POST \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"maxItems":25}' \
  'https://api.apify.com/v2/acts/automation-lab~encar-used-car-listings-scraper/run-sync-get-dataset-items'
```

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/encar-used-car-listings-scraper')
  .call({ maxItems: 25 });
const { items } = await client.dataset(run.defaultDatasetId).listItems({ limit: 25 });
console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/encar-used-car-listings-scraper').call(
    run_input={'maxItems': 25})
print(client.dataset(run['defaultDatasetId']).list_items(limit=25).items)
```

### Use with MCP

Select the stable Actor-specific subset:

```bash
claude mcp add --transport http apify \
  'https://mcp.apify.com?tools=automation-lab/encar-used-car-listings-scraper'
```

For Claude Desktop, Cursor and VS Code, use the equivalent HTTP-client configuration (authentication support depends on your client):

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/encar-used-car-listings-scraper",
      "headers": {"Authorization": "Bearer YOUR_APIFY_TOKEN"}
    }
  }
}
```

Discover actual names and argument schemas with read-only `tools/list`. Actor selection also exposes run/storage helper tools; it does not expose exactly one tool. Example prompt: “Export up to 25 listings from this supported Encar search URL and show model, mileage, raw asking price and source link. Do not convert currency.”

For an authorized invocation, start once and retain the returned run ID and storage IDs. They are metadata, not result rows. A `call-actor` wait is at most 45 seconds (default 30). If nonterminal, follow the same run with `get-actor-run` using bounded 2/4/8-second backoff capped at 10 seconds and a 120-second total deadline. Set the client timeout above the selected wait plus transport margin. On a client timeout recover the known run, never restart to poll; if its ID is unknown, report uncertainty. At the deadline report pending with the run ID. Terminal failures may have partial rows, not a successful full result.

After success use `get-dataset-items` with the returned dataset ID, explicit offset, limit and fields. An example consumer budget is pages of 20 source rows, at most 100 rows and 64 KiB of serialized UTF-8 content admitted to model context, whichever comes first. Enforce the byte ceiling host-side, disclose omitted oversized content, track source offsets and report continuation offset and partial/truncated status. If your client cannot intercept oversized responses, do not claim a hard byte guarantee. Keep full downloads outside model context. These are consumer limits, not changes to Actor collection behavior. Tool discovery/caching behavior depends on the client; no numeric context-saving claim is made.

### Source links and data interpretation

Always retain `sourceUrl`, `url` and `scrapedAt` when loading rows into another system. Recheck the linked public listing before a purchasing decision: a snapshot can be stale, promoted inventory can repeat, and an advertised price is not a completed-sale value. Model labels and region text are kept as supplied rather than translated or standardized.

### Legality and responsible use

Use public listing data responsibly and comply with applicable laws and source terms. Public visibility does not grant unrestricted reuse or establish export eligibility. This Actor is independent of Encar and does not provide legal, valuation or vehicle-condition advice.

The runtime uses no AI or external data-enrichment service. No seller personal contacts, VINs, history reports, dealer photos or raw page bodies are emitted. Raw pages are processed in memory only; there is no cross-run cache or session store. Dataset and log retention follow your Apify storage settings; you control deletion of run storage. Company-managed diagnostic reports expire after 30 days. Failed operations send sanitized diagnostic input, exceptions and actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL queries are removed; reports are retained for 30 days.

### FAQ and troubleshooting

**Why are there fewer rows than requested?** The cap is an upper bound. Each page exposes only a bounded snapshot; duplicates and smaller source results reduce the count.

**Can I use page 2 or a URL with browser-only fragments?** No. The Actor rejects unsupported pagination and fragments. Use a supported first-page URL; do not assume all browser filter states are encoded in a fragment-free URL.

**Why did the run fail instead of returning zero rows?** A permanent HTTP block, missing SSR state, changed action expression or malformed record is not an empty search. Check the run log and retry later only if the upstream condition changed. Report persistent failures with the run link, not credentials.

**Can I fetch contacts, VIN or accident history?** No. Those are outside this listing-snapshot contract.

**Can I normalize the price?** Only after independently confirming the source price convention. Keep raw values and `priceUnit` alongside your own conversion metadata.

### Related marketplace workflows

For separate marketplace coverage, see [Carzone Used Cars Scraper](https://apify.com/automation-lab/carzone-ie-used-car-listings-scraper) and [Blocket Sweden Vehicle Listings](https://apify.com/automation-lab/blocket-sweden-vehicle-listings). Their Irish and Swedish inventories do not replace Encar coverage. Join cross-market datasets only after independently reconciling source units and attributes.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/encar-used-car-listings-scraper/changelog.md

# Actor input Schema

## `startUrls` (type: `array`):

Provide 1–5 HTTPS car.encar.com/list/car URLs. Only page=1 (or omitted) and search parameters are accepted; search JSON must contain type car and action, with optional sort MobileModifiedDate only. Fragments, other hosts, detail URLs and extra parameters are rejected. Filters are source-side Encar action expressions, not Actor-side keyword matching. Each URL is a bounded snapshot, not the full source match count. Omitted input uses the domestic-car example.

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

Global cap on unique vehicle IDs across all URLs, after deduplication. Default 100; range 1–1000; zero/unlimited is unsupported. Processing stops once reached. Upstream snapshots can expose fewer records, so this is not a requested inventory size.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://car.encar.com/list/car?page=1&search=%7B%22type%22%3A%22car%22%2C%22action%22%3A%22(And.Hidden.N._.CarType.Y.)%22%7D"
    }
  ],
  "maxItems": 20
}
```

# Actor output Schema

## `dataset` (type: `string`):

Default dataset containing useful vehicle snapshots.

# 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 = {
    "startUrls": [
        {
            "url": "https://car.encar.com/list/car?page=1&search=%7B%22type%22%3A%22car%22%2C%22action%22%3A%22(And.Hidden.N._.CarType.Y.)%22%7D"
        }
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/encar-used-car-listings-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 = {
    "startUrls": [{ "url": "https://car.encar.com/list/car?page=1&search=%7B%22type%22%3A%22car%22%2C%22action%22%3A%22(And.Hidden.N._.CarType.Y.)%22%7D" }],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/encar-used-car-listings-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 '{
  "startUrls": [
    {
      "url": "https://car.encar.com/list/car?page=1&search=%7B%22type%22%3A%22car%22%2C%22action%22%3A%22(And.Hidden.N._.CarType.Y.)%22%7D"
    }
  ],
  "maxItems": 20
}' |
apify call automation-lab/encar-used-car-listings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/encar-used-car-listings-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/rH5sFJufPYRtxAl88/builds/ROgUmif2tIfl0pT3J/openapi.json