# Cho Tot Scraper: Vietnam Listings, Property & Motorbikes (`accountable_eel/chotot-listing-lookup`) Actor

Cho Tot scraper covering goods, Nha Tot property and Cho Tot Xe vehicles: get one row per listing (price, category, seller, link). Turn on monitoring for only new listings and price drops since your last run. No login required; quiet monitoring runs are free.

- **URL**: https://apify.com/accountable\_eel/chotot-listing-lookup.md
- **Developed by:** [Adrian Voss](https://apify.com/accountable_eel) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 listing returneds

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

## Cho Tot Scraper: Vietnam Listings, Property & Motorbikes

Watch a search, get only what's new. This actor runs your search against **Cho Tot's own public
gateway API** — Vietnam's biggest classifieds group, which also runs the "Nha Tot" property
vertical and the "Cho Tot Xe" vehicles vertical on the same backend — and returns one clean row per
listing: title, price, category, seller, and a link. Turn on monitoring and it becomes a watchlist:
new listings and price drops since your last run, charged per new row, free on quiet days. Schedule
it hourly and send the results to Discord, Slack, Google Sheets, or n8n.

### Who it's for

A reseller or arbitrage buyer watching one category (phones, motorbikes, apartments) on Cho Tot for
underpriced or newly-posted listings wants a live feed of what's actually there right now, without
refreshing the search page by hand. A property agent or renter tracking Hanoi or Ho Chi Minh City
apartment listings on Nha Tot, or a used-vehicle buyer watching Cho Tot Xe for a specific brand and
model, gets the same shape here: paste a keyword, get back a flat row per listing, and pay only for
listings actually returned — a search that finds nothing costs nothing.

This actor covers all three of Cho Tot's verticals from one input (`vertical: goods / property /
vehicles`), because they share the exact same gateway API under the hood — a fact confirmed live,
not assumed from the platform's marketing pages.

### Why this one

- **The only actor covering Cho Tot Xe (vehicles).** The current Apify Store leader for Cho Tot,
  `haketa`, has 15 lifetime users and covers goods only — there is no dedicated actor for used cars
  or motorbikes on Cho Tot at all. This actor adds that vertical from day one, plus Nha Tot property.
- **Monitoring first, not a one-off dump.** Turn on "Only return results that are new, or dropped
  in price" and this actor becomes a watchlist: it remembers every listing ID it has already shown
  you, and only bills you for what's actually new or has dropped in price since the last run. A
  quiet run — nothing new, nothing cheaper — still finishes and costs only the base run fee.
- **Reads Cho Tot's own gateway API directly**, not scraped HTML — `gateway.chotot.com/v1/public/
  ad-listing`, the same JSON endpoint the site's own search pages call. Price, category, and seller
  fields are exact, typed values, not text parsed out of rendered markup.
- **Never charged for a miss, or a quiet monitoring run.** A search that finds nothing, or a
  scheduled watchlist run where nothing changed, still gets a row explaining what happened — and
  costs nothing.
- **Honest about what's actually confirmed.** A handful of fields (the exact listing-page URL slug,
  a house-type or condition code with no discovered label, most Vietnamese provinces' region ids)
  are documented as best-effort or unverified rather than guessed — see "Data & privacy" and the
  FAQ.

### What you get

One row per listing by default (turn off "Expand rows" in Advanced to get one row per search
instead, with the listings nested under `listings`).

| Field | Type | Description |
|---|---|---|
| `query` | text | The search you submitted, echoed back |
| `found` | boolean | `true` if Cho Tot returned a real result for this search |
| `status` | text | `OK` on a match; `NOT_FOUND`, `BLOCKED`, or `BAD_FORMAT` on a miss |
| `message` | text | Plain-English reason for a miss — only present when `found` is `false` |
| `searchQuery` | text | The search line as submitted |
| `vertical` | text | `goods`, `property`, or `vehicles` — inferred from the actual category returned, not just echoed from your setting |
| `listingCount` | number | Listings returned and billed for this search |
| `totalAvailable` | number | Total listings Cho Tot reports matching this search (capped at 10,000 by Cho Tot itself) |
| `truncated` | boolean | `true` if more results existed than were returned |
| `newCount` / `priceDropCount` | number | New listings / price drops this run (monitoring only) |
| `listingId` | text | Cho Tot's public listing id (`list_id` — a different, internal `ad_id` also exists and is never output) |
| `url` | text (link) | Best-effort listing link — see "Data & privacy" for what's unverified about it |
| `title` / `description` | text | Listing title and description (contact info redacted) |
| `price` / `priceDisplay` / `currency` | number / text / text | Price in VND, Cho Tot's own display string, and `VND` always |
| `postedAt` | date | When the listing was posted |
| `category` / `categoryId` | text | Category name and Cho Tot's own numeric `cg` id |
| `region` / `regionId` / `area` / `ward` | text | Province, province id (`region_v2`), district, ward |
| `sellerType` / `sellerRating` / `soldAdsCount` / `sellerHash` | text / number / number / text | `business` or `private`, the seller's average rating, their sold-ads count, and an anonymous per-seller fingerprint |
| `accountName` | text | **Opt-in only.** The seller's raw display name — off unless "Include raw seller name" is on |
| `size`, `rooms`, `toilets`, `houseTypeCode`, `streetName`, `pricePerM2` | — | **Property only** |
| `carBrand`, `carModel`, `year`, `mileageKm`, `fuelCode`, `gearboxCode`, `condition` | — | **Vehicles only** |
| `conditionCode` | number | **Goods only** — a raw Cho Tot code; no label was ever found for it, so it's not translated |
| `changeType`, `isNew`, `previousPrice`, `priceDropPct`, `firstSeenAt` | — | Monitoring-only fields (see "Monitoring" below) |
| `scrapedAt` | date | When this row was fetched |

Deselect any field in the Input tab's column picker to drop it from every row — `query`, `found`,
`status`, `message`, and `scrapedAt` always stay.

### Pricing

Pay-per-event. A flat per-run fee covers session/proxy warmup; you're billed
per item only when data is actually found and returned — see
`.actor/pay_per_event.json` for exact prices. A miss is never charged.

### Monitoring / only new results

Turn on **"Only return results that are new, or dropped in price"** and a search line becomes a
watchlist instead of a one-off dump:

- A listing counts as **new** the first time its Cho Tot listing id is returned by this watchlist.
- A listing counts as a **price drop** when its price falls by at least "Minimum price drop" (5% by
  default) since it was last seen — Cho Tot has no bidding system, so every listed price is a real,
  comparable fixed price.
- Already-seen, unchanged listings are dropped before you're billed. A quiet run — nothing new,
  nothing cheaper — still finishes and returns one free row, so a scheduled task shows it actually
  ran.
- The **first run has nothing to compare against.** By default it returns everything it finds as
  "new". Turn on **"Seed silently"** to instead have the first run bank everything quietly with zero
  rows and zero charge, and start alerting from the second run on.

**Schedule recipe.** Save this actor as an Apify **Task** with `deltaMode: true` and a `deltaName`
you choose, add an hourly (or daily) **Schedule**, and point the task's **webhook** at Discord,
Slack, Google Sheets, or an n8n/Make webhook URL to get pinged only when something actually
changes.

**Price-drop window limitation.** A price drop is only ever seen while the listing is still inside
what a run actually fetches — if a listing falls out of your `maxListingsPerSearch` window or your
price filters between runs, this actor has no way to notice it dropped. Keep searches reasonably
narrow rather than one huge catch-all if price-drop coverage matters to you.

### How to use

1. **In the Apify Console.** Open the actor page and click **Start** — the `searches` field is already pre-filled with a working example. Results land in the run's dataset as soon as each item is found.
2. **Via the API.** Call it directly with a POST request — no Console needed once you have an API token:
   ```bash
   curl "https://api.apify.com/v2/acts/accountable_eel~chotot-listing-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
     -X POST \
     -H "Content-Type: application/json" \
     -d '{"searches":["iphone"]}'
   ```
3. **On a schedule.** Save this actor as an Apify **Task** with the input you want, then add a **Schedule** (hourly, daily, weekly) so it runs on its own — no server of your own required.

4) Pick your **Vertical** (goods / property / vehicles) and, optionally, a **Category** override and
   **Region** under Search settings — see "What you get" and the FAQ for the confirmed category and
   region ids. Turn on "Only return results that are new, or dropped in price" under Monitoring once
   you want a watchlist instead of a one-off dump.

### Input

```json
{
  "searches": [
    "iphone"
  ]
}
```

One per line. A plain keyword ("iphone", "honda") searches the vertical/category/region picked below. A pasted gateway.chotot.com/v1/public/ad-listing URL (copy one from your browser's network tab) overrides cg/st/region\_v2/area\_v2 for that one line only — useful for a for-rent-only property watch, since there is no separate "purpose" field. No login required. Accepted formats: iphone, honda, https://gateway.chotot.com/v1/public/ad-listing?cg=1010\&st=u\&region\_v2=12000.

### Sample output

| query | found | status | searchQuery | vertical | listingCount | totalAvailable | truncated | newCount | priceDropCount | monitorStatus | listings | listingId | url | title | description | price | priceDisplay | currency | postedAt | category | categoryId | region | regionId | area | ward | listingStatus | sellerType | sellerRating | soldAdsCount | photoCount | imageUrl | sellerHash | accountName | size | rooms | toilets | houseTypeCode | streetName | pricePerM2 | carBrand | carModel | year | mileageKm | fuelCode | gearboxCode | condition | conditionCode | changeType | isNew | previousPrice | priceDropPct | firstSeenAt | scrapedAt |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| iphone | true | OK | <search searched> | \<vertical (goods / property / vehicles)> | <listings returned> | <total matching on cho tot> | <more results were available> | <new listings this run> | <price drops this run> | \<monitoring status (quiet / seeded runs)> | \<all listings found (full list)> | \<cho tot listing id (list\_id)> | \<listing link (best-effort, see readme)> | <title> | \<description (contact info redacted)> | \<price (vnd)> | <price as shown on cho tot> | <currency> | <posted at> | <category> | \<category id (cg)> | \<province / city> | \<province id (region\_v2)> | <district> | <ward> | <listing status> | \<business / private> | <seller average rating> | \<seller's sold-ads count> | <photo count> | <image> | <anonymous seller fingerprint> | \<seller display name (raw, opt-in)> | \<property: size (m²)> | \<property: rooms> | \<property: toilets> | \<property: house type (raw code, no label found)> | \<property: street name> | \<property: price per m² (million vnd)> | \<vehicles: car/bike brand> | \<vehicles: car/bike model> | \<vehicles: manufacture year> | \<vehicles: mileage (km)> | \<vehicles: fuel type (raw code, no label found)> | \<vehicles: gearbox (raw code, no label found)> | \<vehicles: condition> | \<goods: condition (raw code, no label found)> | \<new / price-drop / seen> | \<is this listing new?> | \<previous price (vnd)> | \<price drop %> | <first seen on a run> | 1970-01-01T00:00:00.000Z |

A search that finds nothing comes back as a row with `"found": false` and is never charged. A quiet
monitoring run comes back as a row with `listingCount: 0` and is also never charged.

### Use it from Clay, n8n, Make, or an AI agent

This actor runs synchronously over plain HTTP — call it directly from a script, a workflow tool, or an AI agent, no Apify Console needed once you have an API token.

```bash
curl "https://api.apify.com/v2/acts/accountable_eel~chotot-listing-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"searches":["iphone"]}'
```

**n8n.** Add an HTTP Request node: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~chotot-listing-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body Content Type `JSON`, JSON Body `{"searches":["iphone"]}` (swap in an expression from an earlier node for a real value).

**Clay.** Add an "HTTP API" column: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~chotot-listing-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body `{"searches":["{{search}}"]}`, mapping the row's search into the `searches` array.

**MCP.** In Claude, Cursor, or any MCP client with the Apify MCP server, ask for "Cho Tot Scraper | Apify" — the agent will find and run this actor.

For monitoring, point the Task's webhook (Console → your Task → Webhooks) at a Discord or Slack
incoming-webhook URL, a Google Sheets automation, or an n8n/Make workflow's own webhook trigger, so
new listings and price drops land wherever you actually work.

### Tips

- Start monitoring with "Seed silently" on for any watchlist you're setting up on a schedule — it
  avoids a wall of "new" alerts for your entire current search result on day one.
- Want rentals only, or another combination this actor's Input tab doesn't expose directly (like
  Cho Tot's own sale-vs-rent split on property)? Paste a full `gateway.chotot.com/v1/public/
  ad-listing` URL (copy it from your browser's network tab while browsing Nha Tot with the filters
  you want) as a search line — it overrides the vertical/category/region settings for that line.
- Only Ho Chi Minh City and Hanoi have a friendly region name built in. For any other province, run
  once with no region filter and read `regionId` off any returned row for your city, then paste that
  numeric id into "Region" on later runs.
- Keep a monitored search reasonably narrow (a model, a tight category, a price band) — see "Price-
  drop window limitation" above.
- A `BLOCKED` status means Cho Tot returned a 403, 429, or 503 — lowering "Max concurrency" or trying
  again shortly usually clears it; this actor doesn't need a proxy by default.

### vs. haketa's Cho Tot actor, and Cho Tot's own alerts

Cho Tot's own site has no public "save this search and alert me" feature comparable to what this
actor does from outside — the closest thing is manually re-checking a search. The current Apify
Store leader for Cho Tot, `haketa`, has 15 lifetime users and covers the goods vertical only, with
no monitoring mode and no property or vehicles coverage.

| | What it costs | What you get | Trade-off |
|---|---|---|---|
| **This actor** | Pay per listing returned; nothing for a miss or a quiet monitoring run | Goods, Nha Tot property, and Cho Tot Xe vehicles from one actor; monitoring mode (new + price drop) | A handful of fields (exact listing-URL slug, a couple of raw category codes, most provinces' ids) are best-effort or need a numeric id you look up once — see the FAQ |
| **haketa's actor** | Per-listing, goods only | Goods vertical scraping | No property, no vehicles, no monitoring |
| Doing it yourself | Your time to build and maintain a scraper, a seen-listing store, and a price-tracking layer | The same data | This actor's gateway parsing, monitoring state, and redaction are the maintenance burden it absorbs |

### Data & privacy

This actor reads Cho Tot's own public gateway API — the same JSON its search pages call in your
browser, without logging in. It doesn't log in, solve CAPTCHAs, or reveal hidden contact details.
Cho Tot's listing API exposes no phone number or email field of any kind; as a defensive measure,
any phone-like or email-like text a seller pasted directly into a description is still redacted to
`[redacted]`. Seller identity beyond a business/private flag, an average rating, and a sold-ads
count is off by default — turning on "Include raw seller name" would make you responsible for
having a lawful reason to process it. Not affiliated with Cho Tot / Carousell Group.

**Is this allowed?** It collects the same public listing data your browser shows, for the searches
you choose. It's built for monitoring a search, not for copying the marketplace. Check that your
use fits Cho Tot's terms and your local law.

### FAQ

**Why is a row empty, or why does `found` say `false`?**
Either the input line was blank (`status: BAD_FORMAT`), Cho Tot returned a 403/429/503
(`status: BLOCKED`), or the search matched nothing right now (`status: NOT_FOUND`). Check the
`message` column for the specific reason. None of these are billed.

**Am I charged for a quiet monitoring run?**
No. When monitoring finds nothing new and no price drops, you get one row with `listingCount: 0` —
`Actor.charge()` only fires when `listingCount` is greater than zero.

**How sure are you the listing link (`url`) actually works?**
Not fully. Cho Tot's own gateway API returns no link field at all. A real listing URL was observed
once, live, elsewhere on the site: a slug plus the numeric listing id, e.g.
`xe.chotot.com/mua-ban-oto-quan-7-tp-ho-chi-minh/134761051.htm`. The numeric id (confirmed against
this actor's own `listingId`) is real; the descriptive slug text before it was not independently
rebuilt this session, so `url` here is `<domain>/<listingId>.htm` without that slug — unverified for
whether Cho Tot's routing accepts a bare id with no slug prefix.

**What are `houseTypeCode`, `fuelCode`, `gearboxCode`, and `conditionCode`?**
Raw numeric codes Cho Tot returns with no accompanying label anywhere in the payload or the site's
own category data. Rather than invent a translation, this actor outputs the code as-is — cross-check
a code against the listing on chotot.com/nhatot.com/xe.chotot.com if you need its meaning.

**Which category (`cg`) and region (`region_v2`) ids are confirmed?**
Confirmed live: goods 5010 phones (default), 5020 TV/audio, 5030 laptops, 5040 tablets, 5050
cameras; property 1000 all real estate (default), 1010 apartments, 1020 houses, 1040 land, 1050
rooms for rent; vehicles 2010 cars (default), 2020 motorbikes, 2030 parts, 2050 trucks, 2060
bicycles, 2090 electric vehicles. Regions: Ho Chi Minh City (13000) and Hanoi (12000) by name; any
other province needs its numeric `region_v2` id, discoverable for free from `regionId` on any
returned row.

**Do I need to configure proxies?**
No. This actor uses Apify's default proxy configuration (no proxy group) out of the box — Cho Tot's
gateway API isn't Cloudflare-challenged the way its HTML search pages sometimes are. RESIDENTIAL VN
is available as a fallback if that ever changes.

**Can an AI agent call this directly?**
Yes. It's registered on the Apify MCP server — an agent in Claude, Cursor, or another MCP client
can find and run it by name ("Cho Tot Scraper | Apify"), or you can call the REST endpoint shown
above from any script or workflow tool.

### Related actors

- [OLX India Scraper](https://apify.com/accountable_eel/olx-india-listing-lookup) — the same
  search-and-monitor shape for OLX India's own open JSON search API.

# Actor input Schema

## `searches` (type: `array`):

One per line. A plain keyword ("iphone", "honda") searches the vertical/category/region picked below. A pasted gateway.chotot.com/v1/public/ad-listing URL (copy one from your browser's network tab) overrides cg/st/region\_v2/area\_v2 for that one line only — useful for a for-rent-only property watch, since there is no separate "purpose" field. No login required. Accepted formats: iphone, honda, https://gateway.chotot.com/v1/public/ad-listing?cg=1010\&st=u\&region\_v2=12000. You're only charged for the ones we actually find — a miss costs nothing.

## `testRun` (type: `boolean`):

Turn this on to test your input on a small sample before running the full list. Turn it off to process everything.

## `onlyFound` (type: `boolean`):

Only keep rows where something was actually found. Misses are always free, whether or not you show them here.

## `includeKeywords` (type: `array`):

Optional. Only keep results that mention at least one of these words (e.g. a job title, a city, a product name). Leave empty to keep everything.

## `excludeKeywords` (type: `array`):

Optional. Drop any result that mentions one of these words. Leave empty to skip nothing.

## `maxResults` (type: `integer`):

Optional. Stop the run once this many results have been found — useful for a quick, cheap sample. Leave blank for no limit.

## `vertical` (type: `string`):

Sets the default category (cg) for every plain-keyword search line below: goods -> phones (5010), property -> real estate (1000), vehicles -> cars (2010). Override with "Category (cg override)" for a specific sub-category (e.g. 2020 for motorbikes). Ignored for a search line that pastes its own gateway.chotot.com URL.

## `category` (type: `integer`):

Optional. Overrides the vertical's default category id. Confirmed ids: goods 5010 phones / 5020 TV+audio / 5030 laptops / 5040 tablets / 5050 cameras; property 1000 all real estate / 1010 apartments / 1020 houses / 1040 land / 1050 rooms for rent; vehicles 2010 cars / 2020 motorbikes / 2030 parts / 2050 trucks / 2060 bicycles / 2090 electric vehicles. Ignored for a search line that pastes its own gateway.chotot.com URL.

## `region` (type: `string`):

Optional, applies to every plain-keyword search line. "Ho Chi Minh" / "hcm" / "Hanoi" are recognized by name (confirmed live); for any other province, paste its numeric region\_v2 id instead — run once with this empty and read "regionId" off any returned row for your city. Leave empty to search all of Vietnam. Ignored for a search line that pastes its own gateway.chotot.com URL.

## `maxListingsPerSearch` (type: `integer`):

Cho Tot shows 50 listings per page; this actor pages up to 10 times to reach your limit. You pay per listing returned, so this is also your budget control.

## `minPrice` (type: `integer`):

Optional. Applied client-side against each listing's price. Leave empty for no minimum.

## `maxPrice` (type: `integer`):

Optional. Applied client-side against each listing's price. Leave empty for no maximum.

## `deltaMode` (type: `boolean`):

Turns this actor into a monitor. A listing counts as new when its Cho Tot listing ID has not been returned by a previous run of the same watchlist, and as a price drop when its price falls since it was last seen (see "Minimum price drop" below). Already-seen, unchanged listings are dropped before you are billed, so a quiet run costs only the run fee. The first run has nothing to compare against, so (unless "Seed silently" is on) it returns everything and remembers it.

## `deltaName` (type: `string`):

Leave empty and we derive one from this run's search settings, so two schedules with different settings keep separate memories. Type your own name to keep one memory across a settings change, or to have two schedules share one.

## `alertOnNew` (type: `boolean`):

On by default. Turn off to have this watchlist report price drops only, not brand-new listings.

## `alertOnPriceDrop` (type: `boolean`):

On by default. Turn off to have this watchlist report new listings only, ignoring price changes on ones you've already seen.

## `minPriceDropPct` (type: `integer`):

A listing must drop by at least this percentage since it was last seen to be reported as a price-drop.

## `skipFirstRun` (type: `boolean`):

Instead of returning every current listing as "new" the first time a watchlist runs, this banks them silently and starts alerting from the second run on. Stops a fresh watchlist from spamming a hundred messages to your webhook on day one.

## `includeSellerInfo` (type: `boolean`):

Off by default. Turning this on adds the raw seller display name as `accountName`. You always get `sellerType`, `sellerRating`, `soldAdsCount` and `sellerHash` (an anonymous per-seller fingerprint) regardless of this setting. Cho Tot's own listing API never exposes a phone number or email; any phone-like or email-like text a seller pasted into the description is redacted.

## `columns` (type: `array`):

Choose which pieces of information to include in each result row. All are included by default.

## `expandRows` (type: `boolean`):

When on, each listing found gets its own row instead of being grouped under its search. You're still only charged once per search, no matter how many rows it produces.

## `maxConcurrency` (type: `integer`):

Parallel requests. Keep conservative — this target has no browser fallback, so getting blocked costs more than slow-and-steady.

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

Apify Proxy config. Residential recommended for anti-bot-sensitive targets.

## Actor input object example

```json
{
  "searches": [
    "iphone"
  ],
  "testRun": false,
  "onlyFound": false,
  "includeKeywords": [],
  "excludeKeywords": [],
  "vertical": "goods",
  "region": "",
  "maxListingsPerSearch": 50,
  "deltaMode": false,
  "deltaName": "",
  "alertOnNew": true,
  "alertOnPriceDrop": true,
  "minPriceDropPct": 5,
  "skipFirstRun": false,
  "includeSellerInfo": false,
  "columns": [
    "searchQuery",
    "vertical",
    "listingCount",
    "totalAvailable",
    "truncated",
    "newCount",
    "priceDropCount",
    "monitorStatus",
    "listings",
    "listingId",
    "url",
    "title",
    "description",
    "price",
    "priceDisplay",
    "currency",
    "postedAt",
    "category",
    "categoryId",
    "region",
    "regionId",
    "area",
    "ward",
    "listingStatus",
    "sellerType",
    "sellerRating",
    "soldAdsCount",
    "photoCount",
    "imageUrl",
    "sellerHash",
    "accountName",
    "size",
    "rooms",
    "toilets",
    "houseTypeCode",
    "streetName",
    "pricePerM2",
    "carBrand",
    "carModel",
    "year",
    "mileageKm",
    "fuelCode",
    "gearboxCode",
    "condition",
    "conditionCode",
    "changeType",
    "isNew",
    "previousPrice",
    "priceDropPct",
    "firstSeenAt"
  ],
  "expandRows": true,
  "maxConcurrency": 5,
  "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 = {
    "searches": [
        "iphone"
    ],
    "includeKeywords": [],
    "excludeKeywords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("accountable_eel/chotot-listing-lookup").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 = {
    "searches": ["iphone"],
    "includeKeywords": [],
    "excludeKeywords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("accountable_eel/chotot-listing-lookup").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 '{
  "searches": [
    "iphone"
  ],
  "includeKeywords": [],
  "excludeKeywords": []
}' |
apify call accountable_eel/chotot-listing-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,accountable_eel/chotot-listing-lookup"
        }
    }
}
```

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/zpYQeVFzt1uaWmgWL/builds/oZ3jh4UeHoPhHvZMH/openapi.json