# Chotot Listings Scraper (`piotrv1001/chotot-listings-scraper`) Actor

The Chợ Tốt Listings Scraper extracts listings from chotot.com, Vietnam's largest marketplace, capturing titles, prices, descriptions, images, seller info, GPS coordinates, and attributes across phones, real estate, vehicles and electronics — ideal for price monitoring and market research.

- **URL**: https://apify.com/piotrv1001/chotot-listings-scraper.md
- **Developed by:** [FalconScrape](https://apify.com/piotrv1001) (community)
- **Categories:** E-commerce, Real estate, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 product listings

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

### 🚀 Chợ Tốt Listings Scraper

Easily extract listings from [Chợ Tốt](https://www.chotot.com), **Vietnam's largest classifieds marketplace**. The **Chợ Tốt Listings Scraper** lets you gather structured data about products, real estate, vehicles, and more — for price tracking, market research, and lead generation across Vietnam.

### ✨ Features

-   🏷️ **Comprehensive Listing Data**: Titles, descriptions, prices, categories, images, seller info, GPS coordinates, and listing dates.
-   🔍 **Flexible Targeting**: Search by keyword, filter by category (phones, real estate, cars, electronics…) or by region (Ho Chi Minh City, Hanoi…).
-   📋 **Optional Full Details**: Enrich each listing with structured attributes — brand, condition, apartment size, number of rooms, legal documents, and more.
-   🇻🇳 **Nationwide Coverage**: Scrape listings from every province and city in Vietnam.
-   ⚡ **Fast & Efficient**: Collects up to 50 listings per page — 1,000 items in well under a minute.

### 🛠️ How It Works

1. **Enter a search keyword** – e.g. `iphone 15`, `honda wave`, or leave it empty to browse a whole category.
2. **Optionally pick a category or region** – use the category ID (e.g. `1010` for apartments for rent) and region ID (e.g. `13000` for Ho Chi Minh City) from the website's URL.
3. **Set the max items** – control exactly how many listings you want.
4. **Run the scraper** – receive clean, structured JSON instantly. Download it as JSON, CSV, Excel, or HTML.

### ⚙️ Input

```json
{
    "search": "iphone",
    "categoryId": "5010",
    "regionId": "13000",
    "maxItems": 50,
    "scrapeDetails": false
}
````

| Field | Description |
| --- | --- |
| `search` | Keyword to search for. Optional if a category or region is set. |
| `categoryId` | Chợ Tốt category ID, e.g. `1000` real estate, `2010` cars, `5010` phones. |
| `regionId` | Region ID, e.g. `13000` Ho Chi Minh City, `12000` Hanoi. |
| `maxItems` | Maximum number of listings to scrape (default `50`). |
| `scrapeDetails` | Fetch full structured attributes for each listing (slower, costs more). |

### 📊 Sample Output Data

```json
[
    {
        "url": "https://www.chotot.com/132784591.htm",
        "adId": 176542511,
        "listId": 132784591,
        "title": "iPhone Đen",
        "description": "Máy full cn máy màn zin\nPin em mới thay dc 3 hôm",
        "price": 800000,
        "priceString": "800.000 đ",
        "categoryId": 5010,
        "categoryName": "Điện thoại",
        "region": "Thái Bình",
        "area": "Huyện Thái Thụy",
        "ward": "Xã Thái Hòa",
        "latitude": 20.514296,
        "longitude": 106.55546,
        "image": "https://cdn.chotot.com/ECYCf37ATi74bbGyaOS9ytDjds.jpg",
        "images": ["https://cdn.chotot.com/6XXakehZ2nqPGcm1CCqdn.jpg"],
        "sellerId": 26740208,
        "sellerName": "Ngọc Lâm",
        "isShopVerified": false,
        "listedAt": "2026-06-04T08:07:18.000Z"
    }
]
```

With **Scrape full details** enabled, each item additionally includes an `attributes` array with human-readable specifics:

```json
{
    "attributes": [
        { "id": "mobile_brand", "label": "Hãng", "value": "Apple" },
        { "id": "elt_condition", "label": "Tình trạng", "value": "Đã sử dụng (chưa sửa chữa)" },
        { "id": "mobile_capacity", "label": "Dung lượng", "value": "32 GB" }
    ]
}
```

### 💰 Pricing

You pay only for what you scrape:

| Event | Price |
| --- | --- |
| Actor start | $0.005 per run |
| Listing scraped | $0.002 per item |
| Listing detail scraped | $0.005 per item |

Scraping 1,000 listings costs about **$2**, or about **$5** with full details. With Apify's free tier you can try the scraper at no cost.

### 💡 Use Cases

- 📈 **Price monitoring** – track second-hand market prices for phones, vehicles, or electronics in Vietnam.
- 🏠 **Real estate analysis** – collect apartment and house listings with location, size, and legal-status attributes.
- 🚗 **Vehicle market research** – analyze used car and motorbike supply and pricing by region.
- 🎯 **Lead generation** – find active sellers and shops in specific categories and regions.

### ❓ FAQ

**Is it legal to scrape Chợ Tốt?**
This scraper only collects publicly available data. However, you should always review the website's terms of service and consult legal counsel for your specific use case. Personal data is masked at the source (e.g. phone numbers are partially hidden).

**How many listings can I scrape?**
Up to roughly 10,000 listings per search query. Use category and region filters to segment larger datasets.

**Something not working?**
Open an issue in the **Issues** tab of the Actor — we respond quickly and also build custom solutions on request.

Optimize your Vietnam market strategy with the **Chợ Tốt Listings Scraper** today! 🚀

# Actor input Schema

## `search` (type: `string`):

Keyword to search listings for, e.g. <code>iphone 15</code> or <code>honda wave</code>. Leave empty to browse by category or region only.

## `categoryId` (type: `string`):

Optional Chợ Tốt category ID to scrape, e.g. <code>1000</code> (real estate for sale), <code>1010</code> (apartments for rent), <code>2010</code> (cars), <code>5010</code> (phones), <code>5020</code> (TV/audio). You can find the ID in the <code>cg=</code> URL parameter when browsing the website.

## `regionId` (type: `string`):

Optional region ID to limit results to a province/city, e.g. <code>13000</code> for Ho Chi Minh City or <code>12000</code> for Hanoi. You can find it in the <code>region\_v2=</code> URL parameter when browsing the website.

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

Maximum number of listings to scrape.

## `scrapeDetails` (type: `boolean`):

Fetch the full detail of each listing, adding structured attributes (e.g. brand, condition, size, number of rooms, legal documents). Slower and more expensive - one extra request per listing.

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

Proxy settings used for scraping. The default datacenter proxies work well for this site.

## Actor input object example

```json
{
  "search": "iphone",
  "maxItems": 50,
  "scrapeDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

# 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 = {
    "search": "iphone",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("piotrv1001/chotot-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 = {
    "search": "iphone",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("piotrv1001/chotot-listings-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 '{
  "search": "iphone",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call piotrv1001/chotot-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Chotot Listings Scraper",
        "description": "The Chợ Tốt Listings Scraper extracts listings from chotot.com, Vietnam's largest marketplace, capturing titles, prices, descriptions, images, seller info, GPS coordinates, and attributes across phones, real estate, vehicles and electronics — ideal for price monitoring and market research.",
        "version": "0.0",
        "x-build-id": "tRn38is2ho1mmfHON"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/piotrv1001~chotot-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-piotrv1001-chotot-listings-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/piotrv1001~chotot-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-piotrv1001-chotot-listings-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/piotrv1001~chotot-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-piotrv1001-chotot-listings-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": {
                    "search": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "Keyword to search listings for, e.g. <code>iphone 15</code> or <code>honda wave</code>. Leave empty to browse by category or region only."
                    },
                    "categoryId": {
                        "title": "Category ID",
                        "type": "string",
                        "description": "Optional Chợ Tốt category ID to scrape, e.g. <code>1000</code> (real estate for sale), <code>1010</code> (apartments for rent), <code>2010</code> (cars), <code>5010</code> (phones), <code>5020</code> (TV/audio). You can find the ID in the <code>cg=</code> URL parameter when browsing the website."
                    },
                    "regionId": {
                        "title": "Region ID",
                        "type": "string",
                        "description": "Optional region ID to limit results to a province/city, e.g. <code>13000</code> for Ho Chi Minh City or <code>12000</code> for Hanoi. You can find it in the <code>region_v2=</code> URL parameter when browsing the website."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of listings to scrape.",
                        "default": 50
                    },
                    "scrapeDetails": {
                        "title": "Scrape full details",
                        "type": "boolean",
                        "description": "Fetch the full detail of each listing, adding structured attributes (e.g. brand, condition, size, number of rooms, legal documents). Slower and more expensive - one extra request per listing.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings used for scraping. The default datacenter proxies work well for this site.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
