# Carsensor Used Cars Scraper (new listing & price-drop alert) (`superslowsloth/carsensor-used-cars`) Actor

Search Carsensor (カーセンサー), Japan's largest used-car site, by keyword or list URL: one row per car with total and base price in yen, year, mileage, inspection, repair history, dealer and location - labelled new, price_drop, price_rise or unchanged since your last run.

- **URL**: https://apify.com/superslowsloth/carsensor-used-cars.md
- **Developed by:** [Superslow Sloth](https://apify.com/superslowsloth) (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 $2.10 / 1,000 car listing scrapeds

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

## Carsensor Used Cars Scraper (new listing & price-drop alert)

Search [Carsensor](https://www.carsensor.net) (カーセンサー) - Japan's largest
used-car marketplace, run by Recruit, with over half a million cars from
dealers across the country - and get one flat row per car: the all-in total
price (支払総額) and base price in yen, model year, mileage, statutory
inspection (車検), repair history, warranty, displacement, transmission,
body type, colour, where the car is, the dealer and the dealer's review score.

Built as an **alert** for dealers, exporters and buyers: schedule the same
search every hour or every morning, sorted newest first, and each row tells
you whether that car is **new** since the last run, had a **price drop** or a
**price rise**, or is **unchanged**. Turn on *Only changes* and you get - and
pay for - just the new cars and the price moves.

### Input

| field | meaning |
|---|---|
| `keywords` | Free-word searches, as typed into Carsensor's search box, e.g. `プリウス`, `ランドクルーザー 70`, `GT-R`. Each becomes `https://www.carsensor.net/usedcar/freeword/<keyword>/index.html` |
| `searchUrls` | Optional. Result-list URLs copied from your browser - a maker (`/usedcar/bTO/index.html` is every Toyota), a model (`/usedcar/bTO/s004/index.html`), a region or any filtered search. Must be a `/usedcar/.../index.html` list page; a page number (`index3.html`) is kept and the run starts there. Detail pages and other sites are skipped and logged |
| `sort` | Order cars are read in. **Newest listings first by default** - the right order for an alert. Also: oldest, total price low/high, base price low/high, model year new/old, mileage low/high, or Carsensor's own order. A search URL that already carries a `SORT` parameter keeps its own |
| `maxItems` | Stop after reading this many cars in total, shared by every keyword and URL, in order. Carsensor shows 30 cars per page. For an alert this is the window watched: "the newest 100" |
| `changesOnly` | Output only cars that are new or whose total price moved since the previous run of the same search. Off by default |
| `proxyConfiguration` | Apify datacenter proxy by default - see **Proxy** below |

Paging walks `index.html`, `index2.html`, ... and stops on the pager's own
"last page" (its 次へ button is disabled), when `maxItems` is reached, or when
a page brings no car not already seen. Carsensor does **not** 404 past the
end - asking for page 999 of a 370-page search returns page 370 - so the actor
also stops when the page served is not the page it asked for.

### Output

| field | meaning |
|---|---|
| `change` | `new`, `price_drop`, `price_rise` or `unchanged` against the previous run of this search - see **Change tracking** |
| `car_id` | Carsensor's listing id (`AU7216716998`), as in `/usedcar/detail/<id>/index.html` |
| `url` | The car's detail page |
| `maker`, `model`, `grade` | e.g. トヨタ / プリウス / 2.0 Z |
| `catch_copy` | The dealer's catch line that follows the grade in the title |
| `title` | The full title: model, grade and catch line |
| `description` | The dealer's short description under the title |
| `total_price_yen` | 支払総額 - the all-in price to drive it away (car plus taxes, registration and dealer fees). "319.9万円" is `3199000` |
| `base_price_yen` | 車両本体価格 - the car's own price before fees |
| `price_on_request` | `true` when the card says 応談 (ask the dealer) instead of a price |
| `monthly_payment_yen`, `loan_type` | The advertised loan's monthly payment and which loan it is (通常ローン価格 standard, 残価ローン価格 residual-value) |
| `year`, `year_jp` | Model year, Western and Japanese era (`2017`, `H29`) |
| `mileage_km` | Odometer in km ("2.9万km" is `29000`) |
| `inspection`, `inspection_expires` | 車検 as printed (an expiry such as `2027(R09)年05月`, or 車検整備付 / 車検整備無), and that expiry as `2027-05` when it is a date |
| `repair_history` | 修復歴: `true` (あり, has been repaired after an accident) or `false` (なし) |
| `warranty`, `warranty_type` | 保証付 / 保証無, and who gives it: 販売店保証 (the dealer) or ディーラー保証 (a franchised maker dealer) |
| `maintenance` | 法定整備付 (statutory service included) / 法定整備無 |
| `displacement_cc`, `transmission` | e.g. `2000`, フロアCVT |
| `body_type`, `color` | e.g. ハッチバック, 白 |
| `badges` | The card's other labels, e.g. 360°画像付, オンライン相談可, 車両品質評価書付 (third-party condition report) |
| `prefecture`, `city` | Where the car is |
| `shop_name`, `shop_id`, `shop_url` | The selling dealer |
| `shop_review_score`, `shop_review_count` | The dealer's クチコミ評価 (out of 5) and how many reviews it rests on |
| `image_url` | Main photo |
| `query` | The keyword or search URL this row came from |

Everything is read off the search results page - no detail page is opened -
which is what keeps a row cheap. Sponsored lease cars and the "similar cars"
box that Carsensor mixes into its result pages are **not** search results and
are left out.

#### `null` is not zero

Every column except `change`, `car_id`, `url`, `title`, `price_on_request`,
`badges` and `query` can be `null`, and is `null` whenever the card simply
does not print that value - never `0` or an empty string, because a `0` reads
as a measurement. Measured over 258 cards on twelve real pages (2026-10-05):

- `total_price_yen` and `base_price_yen` are null on price-on-request (応談)
  cars - 21 of 258, all of them high-end imports - with `price_on_request: true`;
- `monthly_payment_yen` and `loan_type` are null when no loan is advertised - 122 of 258;
- `shop_review_score` and `shop_review_count` are null when the dealer has no
  reviews yet (printed "－") - 41 of 258;
- `inspection_expires` is null unless 車検 is printed as a date (車検整備付 means
  a fresh inspection is done at delivery);
- `description` (55) and `catch_copy` (30) are blank on some cards.

### Change tracking

Each run remembers what it saw - car id and total price - in a named
key-value store on **your** account, `carsensor-used-cars-watch`, one record
per search (the exact URLs fetched, so a different sort or keyword set is a
different search). The next run of the same search labels each car:

- `new` - not seen by the previous run of this search;
- `price_drop` / `price_rise` - seen before, and the total price (支払総額) moved;
- `unchanged` - seen before at the same price. A price unknown on either side
  (応談) is never a change.

**The first run of a search has nothing to compare with, so every car is
`new`** - the run log says "change tracking: first run". From the second run
on, the labels mean what they say. A car that drops off your window for a run
and comes back is not reported as new again.

With `changesOnly` on, `unchanged` cars are skipped: not in the dataset and
not charged. `maxItems` still bounds how many cars are read, so a run where
nothing changed reads your window and stops.

### Proxy

**Apify datacenter proxy is the default.** Measured 2026-10-05: carsensor.net
answered an Apify datacenter exit with HTTP 200 and the full results page, the
same as from a residential connection. No refusal has been seen. If one does
come back - a 403, 429 or 5xx, or a 200 that is neither a results page nor
Carsensor's "0台" page - the actor switches to a new exit address and retries.
A page still refused after the retries is logged as a failure and nothing is
charged for it.

### Billing

Pay per event: **$0.0021 per car row**, plus a fixed **$0.002 actor-start**
fee per run. Platform usage - compute and proxy - is included. A car is
charged at most once per run, even when two of your searches both return it.
With `changesOnly`, unchanged cars are not charged. A run that fails on its
own input is not charged at all.

### Limits

- Carsensor's refusal page has never been observed, so its classification is
  by elimination: anything that is neither results nor the zero-hit page is
  treated as a refusal and retried.
- The change label compares the **total price** only. A base-price change with
  the same total, or a new photo, is `unchanged`.
- A keyword search is Carsensor's own free-word search, so which cars it
  matches is Carsensor's decision; a maker/model list URL is the exact way to
  name one model.

# Actor input Schema

## `keywords` (type: `array`):

One or more free-word searches, exactly as you would type them into Carsensor's search box, e.g. "プリウス", "ランドクルーザー 70" or "GT-R". Each becomes https://www.carsensor.net/usedcar/freeword/<keyword>/index.html. Every keyword and search URL shares the maxItems budget below, in order - keywords first. Spellings that differ only in case are collapsed before anything is fetched.

## `searchUrls` (type: `array`):

Optional. Carsensor result-list URLs copied from your browser - a maker, a model, a region or any filtered search, e.g. https://www.carsensor.net/usedcar/bTO/s004/index.html. The URL must be a /usedcar/.../index.html list page (a page number such as index3.html is kept and the run starts there); single-car detail pages and anything off carsensor.net are skipped and reported in the run log.

## `sort` (type: `string`):

The order cars are read in. Newest listings first is the default and the right one for an alert: with maxItems 100 each run watches the 100 most recently listed cars. Applies to keywords, and to search URLs that do not already carry a SORT parameter of their own (an order you picked in the browser wins).

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

Stop after reading this many cars in total, shared across every keyword and search URL. Carsensor shows 30 cars per page, so up to 30 per search costs one page request. With 'Only changes' on, this is the window watched - cars read but unchanged since last run are skipped and not charged, and the run still stops here.

## `changesOnly` (type: `boolean`):

Output (and pay for) only cars that are new since the previous run of the same search, or whose total price (支払総額) went down or up. The first run of a search has nothing to compare with, so it labels every car new and outputs all of them; the memory is kept per search in a named key-value store on your account (carsensor-used-cars-watch). Leave off to get every car, each still labelled new / price_drop / price_rise / unchanged.

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

Apify datacenter proxy by default. Measured 2026-10-05: carsensor.net answered a datacenter exit from inside Apify with HTTP 200 and the full results page. Switch to RESIDENTIAL only if runs start reporting refusals.

## Actor input object example

```json
{
  "keywords": [
    "プリウス"
  ],
  "sort": "newest",
  "maxItems": 100,
  "changesOnly": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `listings` (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 = {
    "keywords": [
        "プリウス"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("superslowsloth/carsensor-used-cars").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 = {
    "keywords": ["プリウス"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("superslowsloth/carsensor-used-cars").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 '{
  "keywords": [
    "プリウス"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call superslowsloth/carsensor-used-cars --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,superslowsloth/carsensor-used-cars"
        }
    }
}
```

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/Qf9EcLfOPPrHVvR3K/builds/cQSc7Gds7FgEyA1bg/openapi.json