# JamesEdition Cars Scraper (`solidcode/james-edition-cars-scraper`) Actor

\[💰 $12 / 1K] Extract luxury, classic and supercar listings from JamesEdition. Filter by make, model, year, price, mileage, body type, colour, steering side and country. Get EUR/USD/local prices, full specs, VIN, photo galleries, map coordinates and dealer details.

- **URL**: https://apify.com/solidcode/james-edition-cars-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Automation, Developer tools, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## JamesEdition Cars Scraper

Pull luxury, classic and supercar listings from JamesEdition at scale — prices in three currencies, VIN and full mechanical specs, complete photo galleries, map coordinates, and the dealership and sales contact behind every car. Built for luxury car dealers, collector-market analysts, and lead generation teams who need a clean, structured inventory feed of the high-end market without hand-building search URLs or clicking through listings one at a time.

### Why This Scraper?

- **20 countries with state-level targeting** — every market that currently holds live JamesEdition inventory, from the United States and the United Arab Emirates to Monaco, Japan, Singapore and South Korea, then drill into a region by its official code (`CA` for California, `TX` for Texas, `BY` for Bavaria).
- **Three prices on every car, simultaneously** — euros, US dollars, and the seller's own listed currency with its ISO code. A Dubai listing and a Munich listing sort against each other without a conversion step, and cars sold "price on request" are explicitly flagged instead of appearing as €0.
- **14 body types, including the ones other car feeds skip** — Race Car, Hot Rod, Station / Estate Wagon, RV / Motorhome and Golf Car sit alongside Coupe, Sedan, SUV, Cabriolet, Roadster, Pickup and Limousine.
- **Exterior *and* interior colour filtering — 17 and 16 shades** — both palettes include Two-tone and Custom, so you can isolate a red-on-tan 911 or every two-tone Rolls-Royce in a single query. Most car extractors filter paint only.
- **VIN-level specification block** — VIN, engine, gearbox, fuel type, drivetrain, steering side, condition and the dealer's own stock reference number on each enriched car.
- **Left-hand and right-hand drive filtering, plus 9 sort orders** — isolate import-ready RHD stock, or pair "Price: highest first" with a Max Cars cap to skim only the very top of the market in a short run.
- **Map coordinates on roughly 3 in 4 cars** — latitude and longitude come straight off the listing, so dealer-density maps and radius analysis need no geocoding bill.
- **Full dealer intelligence on every row** — dealership name, address, profile link, how many cars that dealer currently lists, the year they registered, plus the named sales contact and how long they have been on the platform.
- **~50 fields and the complete photo gallery per car** — every image URL, a primary image, and the listing's real photo count, ready to drop into a catalogue or a valuation model.

### Use Cases

**Dealer Inventory Intelligence**
- Track a competing dealership's full stock, price changes and turnover week over week
- Benchmark your own asking prices against every comparable car in your country or region
- Spot dealers who list heavily in a marque you specialise in
- Monitor how long specific models sit before they disappear from the market

**Collector & Investment Research**
- Build model-year price curves for air-cooled 911s, Countachs or Daytonas
- Isolate delivery-mileage cars by capping mileage at 1,000 miles
- Compare classic values across the United States, Germany, Italy and the United Kingdom
- Track the arrival of newly listed cars in a marque you are accumulating

**Lead Generation**
- Build dealer contact lists with dealership name, address, profile link and named sales contact
- Prioritise dealers by inventory size and years on the platform
- Target sellers of a specific make, body type or price band for consignment offers
- Feed enriched dealer records straight into your CRM

**Pricing & Market Analysis**
- Compare the same model across currencies with euro, dollar and local-currency prices side by side
- Measure how colour, mileage and steering side move the asking price
- Chart supply by body type, country and model year
- Quantify how many cars sell "price on request" versus publicly priced

**Marketplace & Product Data**
- Power a luxury-car comparison site or valuation tool with structured listings
- Enrich an existing vehicle database with VIN, specs, photos and coordinates
- Build map-based inventory search from listing latitude and longitude
- Feed high-resolution galleries into listing aggregators and newsletters

### Getting Started

#### Simplest run — one make

```json
{
    "make": "Ferrari",
    "maxResults": 50
}
````

#### Classic collector hunt

Air-cooled Porsche 911s, low mileage, priced from €100,000, most expensive first:

```json
{
    "make": "Porsche",
    "model": "911",
    "yearFrom": 1965,
    "yearTo": 1989,
    "priceMinEur": 100000,
    "mileageMaxMiles": 60000,
    "sortBy": "price_desc",
    "maxResults": 200
}
```

#### Regional lead list with full details

Red and two-tone convertibles in Florida, enriched with VIN, specs and dealer contacts:

```json
{
    "countryCode": "US",
    "regionCode": "FL",
    "bodyTypes": ["cabriolet", "roadster"],
    "exteriorColors": ["red", "two_tone"],
    "steeringSide": ["lhd"],
    "includeDetails": true,
    "maxResults": 300
}
```

#### Batch several ready-made links

```json
{
    "startUrls": [
        "https://www.jamesedition.com/cars/lamborghini",
        "https://www.jamesedition.com/cars/aston-martin/db5"
    ],
    "maxResults": 500
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `make` | string | `"Porsche"` | Car manufacturer, e.g. `Ferrari`, `Rolls Royce`. Leave empty to search every make at once. |
| `model` | string | — | Model within the chosen make, e.g. `911 GT3 RS`. Requires a make. |
| `startUrls` | array | — | One or more JamesEdition car search pages or single car pages. When present, these replace every search field below. |

#### Location

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `countryCode` | string | — | Country the car sits in. 20 options with live inventory: United States, United Arab Emirates, Germany, United Kingdom, Spain, Italy, Japan, Netherlands, Monaco, France, Canada, Austria, New Zealand, Australia, Singapore, Slovakia, Luxembourg, South Korea, Bulgaria, Slovenia. |
| `regionCode` | string | — | State or region **code**, not the full name: `CA` for California, `FL` for Florida, `BY` for Bavaria. Requires a country. |

#### Price, Year & Mileage

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `priceMinEur` | integer | — | Only cars at or above this price, in euros. Applies no matter which currency the seller lists in. |
| `priceMaxEur` | integer | — | Only cars at or below this price, in euros. |
| `yearFrom` | integer | — | Earliest model year, e.g. `2020` for recent cars. |
| `yearTo` | integer | — | Latest model year, e.g. `1975` for classics. |
| `mileageMinMiles` | integer | — | Minimum odometer reading, in miles. |
| `mileageMaxMiles` | integer | — | Maximum odometer reading, in miles. Set `1000` to surface delivery-mileage and collector cars. |

#### Vehicle Attributes

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `bodyTypes` | array | — | 14 styles: Coupe, SUV, Sedan, Cabriolet / Convertible, Pickup, Limousine, Roadster, Race Car, Hot Rod, Station / Estate Wagon, RV / Motorhome, Golf Car, Electric / Green, Other. |
| `exteriorColors` | array | — | 17 shades: Black, White, Grey, Silver, Red, Blue, Green, Yellow, Orange, Brown, Beige, Gold, Purple, Pink, Turquoise, Two-tone, Custom. |
| `interiorColors` | array | — | 16 shades — the same palette minus Pink and Turquoise, plus Tone. |
| `steeringSide` | array | — | Left-hand drive (LHD), Right-hand drive (RHD), or leave empty for both. |

#### Results

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `sortBy` | string | `"premium"` | Featured, Most popular, Recently listed, Price: highest first, Price: lowest first, Year: newest first, Year: oldest first, Mileage: lowest first, Mileage: highest first. |
| `maxResults` | integer | `20` | Cars to collect per search or per start URL. `0` collects everything available. JamesEdition itself serves at most 1,800 cars per search. |
| `includeDetails` | boolean | `false` | Open each car's own page to add the seller description, engine, gearbox, fuel type, drivetrain, condition, VIN, interior colour, exact mileage and the dealership and sales contact. |

### Output

Each car is one flat row, always with the same field set so your columns stay stable.

**These fields need `includeDetails` turned on**, because they live on the car's own page rather than in the search results: `condition`, `bodyType`, `mileageKm`, `mileageMi`, `engine`, `fuelType`, `gearbox`, `driveTrain`, `steeringSide`, `exteriorColor`, `interiorColor`, `vin`, `description`, `region`, `listingAddress`, `officeName`, `officeUrl`, `officeAddress`, `officeListingCount`, `officeRegisteredYear`, `agentName`, `agentTenure`, `listingReference`, `internalReference`, `listedDate` and `lastUpdated`. Everything else arrives on every run.

Example (with `includeDetails` on, description trimmed):

```json
{
    "listingId": 18514026,
    "url": "https://www.jamesedition.com/cars/porsche/panamera/2013-porsche-panamera-turbo-s-sedan-4d-for-sale-18514026",
    "title": "2013 Porsche Panamera Turbo S Sedan 4D",
    "make": "Porsche",
    "model": "Panamera",
    "year": 2013,
    "condition": "Used",
    "bodyType": "Sedan",
    "serpPosition": 11,
    "price": 31998,
    "currency": "USD",
    "priceEur": 28144,
    "priceUsd": 31998,
    "priceFormatted": "€28,126",
    "priceOnRequest": false,
    "mileageKm": 128735,
    "mileageMi": 79992,
    "engine": "8 Cylinder",
    "fuelType": "Petrol",
    "gearbox": "Manual",
    "driveTrain": "Awd",
    "steeringSide": "Lhd",
    "exteriorColor": "White",
    "interiorColor": "Black",
    "vin": "WP0AC2A72DL090226",
    "description": "Introducing the epitome of luxury and performance, the 2013 Porsche Panamera Turbo S in stunning Carrara White...",
    "city": "Gilroy",
    "region": "CA",
    "country": "United States",
    "countryCode": "US",
    "location": "Gilroy, CA, United States",
    "listingAddress": "190 Welburn Ave",
    "latitude": 37.019,
    "longitude": -121.576,
    "officeId": 222199,
    "officeName": "GILROY CAR CLUB LLC",
    "officeUrl": "https://www.jamesedition.com/offices/real_estate/gilroy-car-club-llc-222199",
    "officeAddress": "Gilroy, California, United States",
    "officeListingCount": 5,
    "officeRegisteredYear": "2024",
    "agentName": "GILROY CAR CLUB LLC",
    "agentTenure": "Joined 2 years ago",
    "imageUrls": ["https://img.jamesedition.com/listing_images/.../507x312xc.jpg"],
    "mainImageUrl": "https://img.jamesedition.com/listing_images/.../507x312xc.jpg",
    "photoCount": 24,
    "badges": ["New 7 hours ago"],
    "listingReference": "090226",
    "internalReference": "JE-18514026",
    "listedDate": "2026-07-25",
    "lastUpdated": "2026-07-25",
    "scrapedAt": "2026-07-25T11:04:07.736879+00:00"
}
```

#### Core Listing

| Field | Type | Description |
|-------|------|-------------|
| `listingId` | integer | JamesEdition listing id — a stable key for deduplication |
| `url` | string | Link to the car's own page |
| `title` | string | Full listing title as published |
| `make` | string | Manufacturer |
| `model` | string | Model name |
| `year` | integer | Model year |
| `condition` | string | New, Used or Classic |
| `bodyType` | string | Coupe, Sedan, SUV, Cabriolet, and so on |
| `serpPosition` | integer | Rank of this car within the search results |

#### Pricing

| Field | Type | Description |
|-------|------|-------------|
| `price` | number | Price in the seller's own currency |
| `currency` | string | Seller currency, ISO 4217 (`USD`, `EUR`, `AED`, …) |
| `priceEur` | number | Price in euros |
| `priceUsd` | number | Price in US dollars |
| `priceFormatted` | string | Price exactly as displayed on the listing |
| `priceOnRequest` | boolean | `true` when the seller publishes no public price — the three price fields are then empty rather than zero |

#### Vehicle Specifications

| Field | Type | Description |
|-------|------|-------------|
| `mileageKm` | integer | Odometer reading in kilometres |
| `mileageMi` | integer | Odometer reading in miles |
| `engine` | string | Engine description, e.g. `8 Cylinder` |
| `fuelType` | string | Petrol, diesel, electric or hybrid |
| `gearbox` | string | Automatic or manual |
| `driveTrain` | string | Drivetrain layout, e.g. `Awd`, `Rwd` |
| `steeringSide` | string | `Lhd` or `Rhd` |
| `exteriorColor` | string | Paint colour |
| `interiorColor` | string | Cabin colour |
| `vin` | string | Vehicle identification number |
| `description` | string | Full seller write-up |

#### Location

| Field | Type | Description |
|-------|------|-------------|
| `city` | string | City the car is located in |
| `region` | string | State or region code |
| `country` | string | Country name |
| `countryCode` | string | ISO 3166-1 alpha-2 country code |
| `location` | string | Location as displayed on the listing |
| `listingAddress` | string | Street address where the car sits, when published |
| `latitude` | number | Latitude of the car's location |
| `longitude` | number | Longitude of the car's location |

#### Dealer & Sales Contact

| Field | Type | Description |
|-------|------|-------------|
| `officeId` | integer | Dealership id |
| `officeName` | string | Dealership name |
| `officeUrl` | string | Link to the dealer's profile |
| `officeAddress` | string | Dealership address |
| `officeListingCount` | integer | How many cars this dealer currently lists |
| `officeRegisteredYear` | string | Year the dealership joined the platform |
| `agentName` | string | Named sales contact for this car |
| `agentTenure` | string | How long that contact has been on the platform |

#### Media & Metadata

| Field | Type | Description |
|-------|------|-------------|
| `imageUrls` | array | Every photo URL for the car |
| `mainImageUrl` | string | Primary photo |
| `photoCount` | integer | Number of photos on the listing |
| `badges` | array | Listing badges, e.g. `New 7 hours ago` |
| `listingReference` | string | Dealer's own stock reference number |
| `internalReference` | string | JamesEdition's internal reference for the listing |
| `listedDate` | string | Date the listing went live (ISO 8601) |
| `lastUpdated` | string | Date the listing was last edited (ISO 8601) |
| `scrapedAt` | string | Timestamp of collection (ISO 8601) |

### Tips for Best Results

- **Split big jobs to go past 1,800.** JamesEdition serves a maximum of 1,800 cars for any single search. To sweep a whole marque, run several narrower searches — by country, by model, or by price band (`priceMinEur` / `priceMaxEur` in €100k steps) — and combine the results. Each narrower search gets its own 1,800 allowance.
- **`regionCode` takes a code, never a name.** `CA` works, `California` returns nothing. Same for `FL`, `TX` and `BY`.
- **Mileage filters are always in miles.** The site compares odometers in miles even when a listing displays kilometres. Your output still carries both `mileageKm` and `mileageMi`.
- **Price filters are always in euros.** `priceMinEur` and `priceMaxEur` compare against the euro value of every car, whatever currency the dealer listed in — so one range works worldwide.
- **Turn `includeDetails` off for a fast market sweep.** Title, make, model, year, all three prices, city, country, map coordinates, badges and the full photo gallery arrive without it. Turn it on when you need mileage, colours, condition, body type, VIN, engine, the seller write-up or dealer contacts.
- **Interior colours are not the same palette as exterior.** Pink and Turquoise exist as paint only — asking for them as an interior returns nothing. Two-tone and Custom are available on both.
- **Skim the top of the market cheaply.** Set `sortBy` to `Price: highest first` with a small `maxResults` to capture just the headline cars in a marque, instead of paying for the whole inventory to find them.

### Pricing

**From $12.00 per 1,000 results** — well under the going rate for luxury marketplace data. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $1.44 | $1.36 | $1.28 | $1.20 |
| 1,000 | $14.40 | $13.55 | $12.75 | $12.00 |
| 10,000 | $144.00 | $135.50 | $127.50 | $120.00 |
| 100,000 | $1,440.00 | $1,355.00 | $1,275.00 | $1,200.00 |

A "result" is one car row in the output dataset. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger your own endpoints when a run finishes
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is built for legitimate market research, inventory analysis, valuation work, and business development in the luxury and collector car trade. It collects only listing information that JamesEdition publishes openly. You are responsible for complying with applicable laws, data protection rules, and JamesEdition's Terms of Service. Do not use the extracted data for spam, harassment, or any unlawful purpose, and treat dealer and contact details as business data subject to marketing and privacy regulations in your jurisdiction.

# Actor input Schema

## `make` (type: `string`):

Car manufacturer to search, for example "Porsche", "Ferrari", "Mercedes" or "Rolls Royce". Leave empty to search every make at once. Ignored when Start URLs are provided.

## `model` (type: `string`):

Model within the chosen make, for example "911 GT3 RS", "Cayenne" or "Mustang". Requires a Make. Leave empty to include every model.

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

Paste one or more JamesEdition links, either car search pages or single car pages. When provided, these replace the search fields above and below.

## `countryCode` (type: `string`):

Only include cars located in this country. Only the 20 countries listed here currently have cars for sale on JamesEdition. Leave empty to search worldwide.

## `regionCode` (type: `string`):

Official short region code only — NOT the full name. Use "CA" for California, "FL" for Florida, "TX" for Texas, "BY" for Bavaria. Typing "California" returns nothing. Requires a Country. Leave empty for the whole country.

## `priceMinEur` (type: `integer`):

Only include cars at or above this price, in euros. JamesEdition compares prices in euros no matter which currency a seller lists in. Leave empty for no minimum.

## `priceMaxEur` (type: `integer`):

Only include cars at or below this price, in euros. Leave empty for no maximum.

## `yearFrom` (type: `integer`):

Only include cars from this model year or later, for example 2020 for recent cars. Leave empty for any year.

## `yearTo` (type: `integer`):

Only include cars from this model year or earlier, for example 1975 for classics. Leave empty for any year.

## `mileageMinMiles` (type: `integer`):

Only include cars with at least this many miles on the odometer. JamesEdition filters mileage in miles even when a listing displays kilometres. Leave empty for any mileage.

## `mileageMaxMiles` (type: `integer`):

Only include cars with at most this many miles on the odometer. Set a low number such as 1000 to find delivery-mileage and collector cars. Leave empty for any mileage.

## `bodyTypes` (type: `array`):

Only include these body styles. Leave empty to include every type.

## `exteriorColors` (type: `array`):

Only include cars in these exterior colours. Leave empty to include every colour.

## `interiorColors` (type: `array`):

Only include cars with these interior colours. The interior palette is not identical to the exterior one — pink and turquoise interiors are not offered. Leave empty to include every colour.

## `steeringSide` (type: `array`):

Only include left-hand drive or right-hand drive cars. Leave empty to include both.

## `sortBy` (type: `string`):

Choose the order in which cars are collected. Useful together with Max Cars — for example sort by highest price to collect only the top of the market.

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

Maximum number of cars to collect per search (or per Start URL). Set to 0 to collect everything available. JamesEdition itself stops paginating after 1,800 cars per search, so one search can never return more than 1,800 no matter how high you set this — split large jobs by make, country or price band to go beyond that.

## `includeDetails` (type: `boolean`):

Open each car's own page to add the full seller description, engine, gearbox, fuel type, drivetrain, condition, VIN, interior colour, exact mileage, the dealership's name, address and profile, and the sales contact. This adds one extra page load per car, so runs take longer. Leave off for a fast overview with photos, prices and location only.

## Actor input object example

```json
{
  "make": "Porsche",
  "sortBy": "premium",
  "maxResults": 20
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of collected car listings with make, model, year, prices, location, map coordinates and photo count.

## `specs` (type: `string`):

Condition, body type, mileage, engine, gearbox, drivetrain, steering side, colours, VIN and reference numbers. Populated when Include full details is on.

## `sellers` (type: `string`):

Dealership and sales-contact details for every collected car. Populated when Include full details is on.

# 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 = {
    "make": "Porsche",
    "sortBy": "premium",
    "maxResults": 20,
    "includeDetails": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/james-edition-cars-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 = {
    "make": "Porsche",
    "sortBy": "premium",
    "maxResults": 20,
    "includeDetails": False,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/james-edition-cars-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 '{
  "make": "Porsche",
  "sortBy": "premium",
  "maxResults": 20,
  "includeDetails": false
}' |
apify call solidcode/james-edition-cars-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "JamesEdition Cars Scraper",
        "description": "[💰 $12 / 1K] Extract luxury, classic and supercar listings from JamesEdition. Filter by make, model, year, price, mileage, body type, colour, steering side and country. Get EUR/USD/local prices, full specs, VIN, photo galleries, map coordinates and dealer details.",
        "version": "1.0",
        "x-build-id": "isOWsRO2pazWU1f8c"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~james-edition-cars-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-james-edition-cars-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/solidcode~james-edition-cars-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-james-edition-cars-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/solidcode~james-edition-cars-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-james-edition-cars-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": {
                    "make": {
                        "title": "Make",
                        "type": "string",
                        "description": "Car manufacturer to search, for example \"Porsche\", \"Ferrari\", \"Mercedes\" or \"Rolls Royce\". Leave empty to search every make at once. Ignored when Start URLs are provided."
                    },
                    "model": {
                        "title": "Model",
                        "type": "string",
                        "description": "Model within the chosen make, for example \"911 GT3 RS\", \"Cayenne\" or \"Mustang\". Requires a Make. Leave empty to include every model."
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Paste one or more JamesEdition links, either car search pages or single car pages. When provided, these replace the search fields above and below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "countryCode": {
                        "title": "Country",
                        "enum": [
                            "US",
                            "AE",
                            "DE",
                            "GB",
                            "ES",
                            "IT",
                            "JP",
                            "NL",
                            "MC",
                            "FR",
                            "CA",
                            "AT",
                            "NZ",
                            "AU",
                            "SG",
                            "SK",
                            "LU",
                            "KR",
                            "BG",
                            "SI"
                        ],
                        "type": "string",
                        "description": "Only include cars located in this country. Only the 20 countries listed here currently have cars for sale on JamesEdition. Leave empty to search worldwide."
                    },
                    "regionCode": {
                        "title": "State / Region Code",
                        "type": "string",
                        "description": "Official short region code only — NOT the full name. Use \"CA\" for California, \"FL\" for Florida, \"TX\" for Texas, \"BY\" for Bavaria. Typing \"California\" returns nothing. Requires a Country. Leave empty for the whole country."
                    },
                    "priceMinEur": {
                        "title": "Minimum Price (EUR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include cars at or above this price, in euros. JamesEdition compares prices in euros no matter which currency a seller lists in. Leave empty for no minimum."
                    },
                    "priceMaxEur": {
                        "title": "Maximum Price (EUR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include cars at or below this price, in euros. Leave empty for no maximum."
                    },
                    "yearFrom": {
                        "title": "Year From",
                        "minimum": 1900,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Only include cars from this model year or later, for example 2020 for recent cars. Leave empty for any year."
                    },
                    "yearTo": {
                        "title": "Year To",
                        "minimum": 1900,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Only include cars from this model year or earlier, for example 1975 for classics. Leave empty for any year."
                    },
                    "mileageMinMiles": {
                        "title": "Minimum Mileage (miles)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include cars with at least this many miles on the odometer. JamesEdition filters mileage in miles even when a listing displays kilometres. Leave empty for any mileage."
                    },
                    "mileageMaxMiles": {
                        "title": "Maximum Mileage (miles)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include cars with at most this many miles on the odometer. Set a low number such as 1000 to find delivery-mileage and collector cars. Leave empty for any mileage."
                    },
                    "bodyTypes": {
                        "title": "Body Types",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include these body styles. Leave empty to include every type.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "coupe",
                                "suv",
                                "sedan",
                                "cabriolet",
                                "pickup",
                                "limousine",
                                "roadster",
                                "race_car",
                                "hot_rod",
                                "station_estate_wagon",
                                "rv",
                                "golf car",
                                "green_electric",
                                "other"
                            ],
                            "enumTitles": [
                                "Coupe",
                                "SUV",
                                "Sedan",
                                "Cabriolet / Convertible",
                                "Pickup",
                                "Limousine",
                                "Roadster",
                                "Race Car",
                                "Hot Rod",
                                "Station / Estate Wagon",
                                "RV / Motorhome",
                                "Golf Car",
                                "Electric / Green",
                                "Other"
                            ]
                        }
                    },
                    "exteriorColors": {
                        "title": "Exterior Colours",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include cars in these exterior colours. Leave empty to include every colour.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "black",
                                "white",
                                "grey",
                                "silver",
                                "red",
                                "blue",
                                "green",
                                "yellow",
                                "orange",
                                "brown",
                                "beige",
                                "gold",
                                "purple",
                                "pink",
                                "turquoise",
                                "two_tone",
                                "custom"
                            ],
                            "enumTitles": [
                                "Black",
                                "White",
                                "Grey",
                                "Silver",
                                "Red",
                                "Blue",
                                "Green",
                                "Yellow",
                                "Orange",
                                "Brown",
                                "Beige",
                                "Gold",
                                "Purple",
                                "Pink",
                                "Turquoise",
                                "Two-tone",
                                "Custom"
                            ]
                        }
                    },
                    "interiorColors": {
                        "title": "Interior Colours",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include cars with these interior colours. The interior palette is not identical to the exterior one — pink and turquoise interiors are not offered. Leave empty to include every colour.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "black",
                                "white",
                                "grey",
                                "silver",
                                "red",
                                "blue",
                                "green",
                                "yellow",
                                "orange",
                                "brown",
                                "beige",
                                "gold",
                                "purple",
                                "two_tone",
                                "custom",
                                "tone"
                            ],
                            "enumTitles": [
                                "Black",
                                "White",
                                "Grey",
                                "Silver",
                                "Red",
                                "Blue",
                                "Green",
                                "Yellow",
                                "Orange",
                                "Brown",
                                "Beige",
                                "Gold",
                                "Purple",
                                "Two-tone",
                                "Custom",
                                "Tone"
                            ]
                        }
                    },
                    "steeringSide": {
                        "title": "Steering Side",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include left-hand drive or right-hand drive cars. Leave empty to include both.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "lhd",
                                "rhd"
                            ],
                            "enumTitles": [
                                "Left-hand drive (LHD)",
                                "Right-hand drive (RHD)"
                            ]
                        }
                    },
                    "sortBy": {
                        "title": "Sort Results By",
                        "enum": [
                            "premium",
                            "popular",
                            "recent",
                            "price_desc",
                            "price_asc",
                            "year_desc",
                            "year_asc",
                            "mileage_asc",
                            "mileage_desc"
                        ],
                        "type": "string",
                        "description": "Choose the order in which cars are collected. Useful together with Max Cars — for example sort by highest price to collect only the top of the market."
                    },
                    "maxResults": {
                        "title": "Max Cars",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of cars to collect per search (or per Start URL). Set to 0 to collect everything available. JamesEdition itself stops paginating after 1,800 cars per search, so one search can never return more than 1,800 no matter how high you set this — split large jobs by make, country or price band to go beyond that."
                    },
                    "includeDetails": {
                        "title": "Include Full Car Details",
                        "type": "boolean",
                        "description": "Open each car's own page to add the full seller description, engine, gearbox, fuel type, drivetrain, condition, VIN, interior colour, exact mileage, the dealership's name, address and profile, and the sales contact. This adds one extra page load per car, so runs take longer. Leave off for a fast overview with photos, prices and location only."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
