# 28car API (`truefetch/28car-api`) Actor

28car API for public Hong Kong vehicle listings by keyword. Return 37 normalized fields for HKD prices, vehicle attributes, seller context, images, and source URLs with 28car-only routing.

- **URL**: https://apify.com/truefetch/28car-api.md
- **Developed by:** [TrueFetch](https://apify.com/truefetch) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.50 / 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/actors/running/actors-in-store.md#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

**28car API is a 28car api that searches public Hong Kong vehicle advertisements by keyword and returns 37 normalized fields with HKD prices and original listing links.**

- **The runtime is locked to 28car rather than a user-selected fallback source.**
- **Hong Kong is the accepted market for this focused edition.**
- **The input contains only result limit, market, and keyword controls.**
- **Source text and unavailable values are preserved rather than translated or invented.**

[**Run a one-result test**](https://apify.com/truefetch/28car-api) · [**View API**](https://apify.com/truefetch/28car-api/api)

Set `max_results` to `1` for the smallest useful test. Billing includes Actor Start and only the result rows actually written to the default Dataset.

### What does 28car API do?

28car API turns a public vehicle search into structured Dataset rows for Hong Kong through the public 28car marketplace. It accepts the current schema inputs, follows the edition's routing rules, and writes source-linked records that can move directly into JSON, CSV, Excel, a database, or another Apify workflow.

The official 28car marketplace publishes searchable vehicle sale advertisements; listing language and field completeness depend on each seller. [See the official 28car marketplace](https://m.28car.com/).

The Actor is a collection and normalization tool, not a vehicle-history report, appraisal, inspection, financing decision, or guarantee of current stock. Important commercial facts should be checked on `source_url`, because listings and catalog pages can change after collection.

### How do I run 28car API?

Run 28car API by starting with its prefilled scenario, reviewing one source-linked row, and increasing scope only after the data matches the intended workflow.

1. Open the [28car API input page](https://apify.com/truefetch/28car-api) and review every required value.
2. Set `country` to `Hong Kong`, `keyword` to `Honda`, and `max_results` to `6`; for the smallest risk test, temporarily use `max_results: 1`.
3. Start the Actor and wait for the default Dataset.
4. Open `source_url` from a returned row before expanding the result ceiling or scheduling repeats.

```json
{
  "max_results": 6,
  "country": "Hong Kong",
  "keyword": "Honda"
}
```

The result limit is a ceiling rather than a promise. Live inventory, source access, unique listing URLs, and the fields available on each page determine how many records can be published.

### What data does 28car API return?

28car API returns one object per source record using exactly 37 public fields. Values unavailable from the source remain empty; the Actor does not derive a VIN, seller, mileage, location, or vehicle specification from the keyword.

| Field group | Public fields | Meaning |
| --- | --- | --- |
| Identity and price | `main_image`, `title`, `price`, `currency`, `year`, `make`, `model`, `trim` | Primary media, listing title, asking price, and vehicle identity. |
| Mileage and geography | `mileage`, `mileage_unit`, `location`, `latitude`, `longitude`, `country` | Odometer values and source-published place data. |
| Source and seller | `platform`, `source_url`, `seller`, `seller_type` | Marketplace attribution, original listing link, and public seller context. |
| Vehicle attributes | `condition`, `body_type`, `seats`, `fuel`, `transmission`, `engine`, `drive_type`, `exterior_color`, `interior_color`, `vin` | Source-published condition, dimensions, powertrain, colors, and identifiers. |
| Lifecycle and content | `listing_id`, `posted_at`, `updated_at`, `description`, `images`, `price_text`, `official_url`, `processor`, `processed_at` | Source identity, dates, descriptive content, additional links, and processing attribution. |

This abbreviated illustrative item uses the same scenario; a real row follows the full 37-field schema.

```json
{
  "title": "HONDA FREED HYBRID",
  "price": 128000,
  "currency": "HKD",
  "year": 2021,
  "make": "HONDA",
  "model": "FREED",
  "fuel": "HYBRID",
  "country": "Hong Kong",
  "platform": "28car",
  "source_url": "https://m.28car.com/sell_dsp.php?h_vid=example",
  "processed_at": "2026-08-10T08:03:12Z"
}
```

Apify Datasets support JSON, JSONL, CSV, Excel, XML, HTML, and RSS retrieval through the [Dataset items API](https://docs.apify.com/api/v2/dataset-items-get). Keep `source_url` and `processed_at` when exporting so later reviews retain both source provenance and collection time.

### What inputs can I configure?

28car API exposes only inputs supported by its current runtime route, with required fields marked explicitly and no invented non-empty fallback for optional filters.

| Input | Type | Required | Behavior | Example |
| --- | --- | --- | --- | --- |
| `max_results` | integer | Yes | Maximum 28car records returned by the run. | `6` |
| `country` | string | Yes | Required market input; this edition accepts Hong Kong. | `"Hong Kong"` |
| `keyword` | string | Yes | Required make, model, or vehicle phrase, sent without translation. | `"Honda"` |

The complete effective test input is formed from schema defaults overridden by prefills. API callers can replace those values, but must still send each required field with a schema-valid value.

### What platforms and markets does 28car API cover?

28car API covers Hong Kong through the public 28car marketplace; coverage follows the source relationships registered for this edition rather than assumptions based on the Actor's title.

This Actor covers one source and one market. It does not route to another classified site when a request returns no record.

Traditional Chinese and English text may both appear because the Actor preserves source copy. Downstream translation should remain separate from collection.

Source inventory, language, seller-entered fields, and page availability change independently. The Dataset describes what was available when the run processed each record.

### Why use 28car API?

28car API is useful when a repeatable API and Dataset contract matters more than manually copying vehicle cards or maintaining a source-specific export parser.

| Capability | Practical benefit |
| --- | --- |
| Fixed 28car attribution | Build a Hong Kong sample without mixing marketplaces. |
| HKD price normalization | Compare numeric asking prices while retaining the source-formatted price text. |
| Source-language preservation | Keep seller terminology intact for review or downstream translation. |
| 37-field Dataset | Store repeat runs in stable columns even when optional values are absent. |
| Direct listing links | Open the original advertisement before making a pricing or inventory decision. |

Focus improves source attribution, but one marketplace cannot represent the whole Hong Kong vehicle market and not every ad carries every normalized field. This is why null handling and source-link retention are part of a reliable downstream design rather than cleanup tasks.

### Who is 28car API for?

28car API is designed for developers, Hong Kong automotive analysts, dealer researchers, inventory monitors, and data operations teams that need repeatable 28car samples. It works for teams that need a reproducible input, structured output, and a review path back to each public source record.

Useful workflows include Honda availability checks, HKD asking-price bands, source-link review queues, make-level inventory snapshots, and scheduled comparisons of listing IDs. Six results are enough to exercise paging without turning the first integration into a large harvest.

It is not for mechanical inspections, private seller enrichment, guaranteed ownership history, appraisal values, or multi-country coverage. Vehicle purchases, lending, insurance, safety, and regulatory decisions require independent checks beyond a scraped public listing.

### How can I use 28car API through the API or MCP?

28car API has the public Actor ID `jjMtts2rgrncCFDTM`; the stable name form `truefetch/28car-api` is also available for human-readable integrations.

```text
jjMtts2rgrncCFDTM
```

This synchronous HTTP request uses the same scenario and returns Dataset items directly:

```bash
curl -L "https://api.apify.com/v2/acts/jjMtts2rgrncCFDTM/run-sync-get-dataset-items?maxItems=1" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer <APIFY_TOKEN>" \
  -d '{"max_results":6,"country":"Hong Kong","keyword":"Honda"}'
```

Apify also provides a hosted Streamable HTTP MCP server:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=actors,docs"
    }
  }
}
```

After authentication, ask the MCP client to inspect Actor ID `jjMtts2rgrncCFDTM`, run the same input, and return the default Dataset rows. The [28car API API page](https://apify.com/truefetch/28car-api/api) provides generated SDK and OpenAPI examples, while the [Apify MCP guide](https://docs.apify.com/integrations/mcp) documents current client setup.

### How much does 28car API cost?

28car API costs $0.00600 per result on the FREE tier plus $0.01000 per Actor Start event; memory determines the number of Start events at one per GB, minimum one.

| Event or tier | Price | Billing unit |
| --- | ---: | --- |
| Actor Start | $0.01000 | Per GB of Actor memory, minimum one event. |
| Result — FREE | $0.00600 | One item written to the default Dataset. |
| Result — BRONZE | $0.00540 | One Dataset item. |
| Result — SILVER | $0.00480 | One Dataset item. |
| Result — GOLD | $0.00450 | One Dataset item. |
| Result — PLATINUM | $0.00450 | One Dataset item. |
| Result — DIAMOND | $0.00450 | One Dataset item. |

Smallest-test calculation, assuming the minimum one Start event: $0.01000 Actor Start + 1 result × $0.00600 = **$0.01600**. A run that writes no row can still incur Actor Start. Check the [live pricing page](https://apify.com/truefetch/28car-api/pricing) before budgeting a larger workflow because prices can change.

### How does 28car API compare with alternatives?

28car API is the best fit when its documented source and normalized contract match the job; broader, manual, or contractual approaches solve different problems.

| Option | Best fit | Trade-off |
| --- | --- | --- |
| 28car API | Repeatable, source-locked 28car research through Apify. | Limited to one Hong Kong marketplace. |
| Car Listings API | Country-aware research across many vehicle sources. | A broader form is unnecessary for 28car-only work. |
| Manual 28car browsing | One-off buying research with full native page context. | Difficult to automate, export, or compare on a schedule. |
| A custom source integration | Teams requiring private workflow logic or additional native fields. | Ongoing parser, proxy, and schema maintenance. |

No option eliminates the need to verify a mutable vehicle advertisement before a purchase or other high-impact decision.

### What are the limits and troubleshooting steps?

28car API depends on public source responses, so troubleshooting begins with the exact input, the current source page, and whether the default Dataset contains a row.

| Symptom or limit | Explanation and next step |
| --- | --- |
| Another country is rejected | Hong Kong is the only accepted runtime market for this edition. |
| No location field exists | The 28car request path has no supported user-supplied location control. |
| No matching row is returned | Use a broad public make such as `Honda` and confirm current ads exist on 28car. |
| Chinese text appears | Source language is preserved intentionally; translate downstream if required. |
| A saved URL stops working | Advertisements can be edited or removed. Rerun and treat the older row as historical. |

For a reproducible report, use `max_results: 1`, include the run ID and exact input, and add one public source URL when available. Never include an Apify token, private seller data, or credentials in an [Issue](https://apify.com/truefetch/28car-api/issues).

### Frequently asked questions

#### Which inputs are required?

All three inputs are required: `max_results`, `country`, and `keyword`.

#### Is this a 28car car listings api?

Yes. It searches public 28car advertisements and delivers normalized rows through Apify Dataset and API endpoints.

#### Can this act as a hong kong used car api?

Yes for public 28car listing research, but it is not an official registration, inspection, valuation, or history service.

#### Can I choose a different country?

No. The focused edition accepts Hong Kong because the runtime is locked to 28car.

#### Is there a free vehicle listings API?

The Actor can be tested within Apify plan allowances, but each run start and each result follow the displayed pay-per-event prices.

#### Can I schedule runs to monitor 28car listings over time?

Yes. Keep the Honda input stable and compare `listing_id`, `price`, and `source_url` across scheduled Datasets.

#### Why can mileage or seller be empty?

An individual advertisement may not expose the value in a form the normalized schema can support.

### Related TrueFetch Actors

Three TrueFetch Actors cover the closest adjacent vehicle markets without duplicating this Actor's exact source scope.

- [Car Listings API](https://apify.com/truefetch/car-listings-api) — Choose it when several markets or sources are needed.
- [CarDekho API](https://apify.com/truefetch/cardekho-api) — Choose it for India-focused vehicle records.
- [Autohome API](https://apify.com/truefetch/autohome-api) — Choose it for Mainland China vehicle listings.

### Support

Use the [Store page](https://apify.com/truefetch/28car-api) for the input, the [API page](https://apify.com/truefetch/28car-api/api) for generated integration examples, and [Issues](https://apify.com/truefetch/28car-api/issues) for a reproducible bug. Discuss vehicle-data workflows in the [TrueFetch community on Telegram](https://t.me/TrueFetch).

[**Run a focused 28car API test**](https://apify.com/truefetch/28car-api) · [**Open the 28car API API**](https://apify.com/truefetch/28car-api/api)

**Last Updated:** August 10, 2026

# Actor input Schema

## `max_results` (type: `integer`):

Maximum public 28car vehicle records returned by this run.

## `country` (type: `string`):

Required market input; this source-locked 28car API accepts Hong Kong.

## `keyword` (type: `string`):

Required 28car make, model, or vehicle phrase preserved as submitted.

## `platforms` (type: `array`):

Source selector fixed to 28car for this edition.

## `location` (type: `string`):

Optional contract field; 28car rejects locations it cannot send through a native source request.

## Actor input object example

```json
{
  "max_results": 6,
  "country": "Hong Kong",
  "keyword": "Honda",
  "platforms": [
    "28car"
  ]
}
```

# Actor output Schema

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

Open the overview table for normalized vehicle listings from the selected supported platforms.

# 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 = {
    "max_results": 6,
    "country": "Hong Kong",
    "keyword": "Honda",
    "platforms": [
        "28car"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("truefetch/28car-api").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 = {
    "max_results": 6,
    "country": "Hong Kong",
    "keyword": "Honda",
    "platforms": ["28car"],
}

# Run the Actor and wait for it to finish
run = client.actor("truefetch/28car-api").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 '{
  "max_results": 6,
  "country": "Hong Kong",
  "keyword": "Honda",
  "platforms": [
    "28car"
  ]
}' |
apify call truefetch/28car-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,truefetch/28car-api"
        }
    }
}

```

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/jjMtts2rgrncCFDTM/builds/tdsdH7GHOcfv1oV9h/openapi.json