# PistonHeads Scraper: UK Used, Classic & Performance Cars (`fayoussef/pistonheads`) Actor

Our pistonheads.com scraper effortlessly gathers URLs from all pages and extracts detailed information from each listing card.

- **URL**: https://apify.com/fayoussef/pistonheads.md
- **Developed by:** [Youssef Farhan](https://apify.com/fayoussef) (community)
- **Categories:** Automation, Developer tools, Other
- **Features:** Limited permissions
- **Stats:** 12 total users, 0 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

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

## PistonHeads Scraper: UK Used, Classic & Performance Cars

Scrape PistonHeads.com car listings at scale with this actor that reads the site's own pagination API and extracts 30+ structured fields per vehicle, including GBP price, engine specs, CO2 emissions, fuel consumption, seller phone, and location data. Built for UK car dealerships, automotive data teams, and market researchers who need comprehensive classified ad data from one of the UK's most active enthusiast car marketplaces.

### What you get

**Listing info**

- `url`: direct link to the listing on PistonHeads.com
- `condition`: New or Used
- `status`: active/sold

**Vehicle specs**

- `manufacturer`, `model`, `version`
- `registration_year`
- `body_type`, `transmission`, `fuel_type`
- `engine_size`, `engine_power`
- `co2_emissions`, `fuel_consumption`
- `doors`, `seats`
- `exterior_colour`
- `number_of_owners`

**Pricing**

- `price`: numeric GBP value
- `formatted_price`: display string (e.g., "£24,995")
- `currency`: GBP

**Mileage**

- `mileage`: odometer reading

**Location**

- `city`, `county`, `postcode`, `country`

**Seller**

- `seller_name`
- `seller_type`: Private or Dealer
- `seller_phone`

### Sample output

```json
{
  "url": "https://www.pistonheads.com/buy/listing/12345678",
  "manufacturer": "Porsche",
  "model": "911",
  "version": "Carrera S",
  "registration_year": 2019,
  "condition": "Used",
  "price": 89995,
  "formatted_price": "£89,995",
  "currency": "GBP",
  "mileage": 22000,
  "body_type": "Coupe",
  "transmission": "Automatic",
  "fuel_type": "Petrol",
  "engine_size": "3.0L",
  "engine_power": "450bhp",
  "co2_emissions": "205g/km",
  "fuel_consumption": "30mpg",
  "doors": 2,
  "seats": 4,
  "exterior_colour": "Guards Red",
  "number_of_owners": 2,
  "city": "London",
  "county": "Greater London",
  "postcode": "SW1A 1AA",
  "country": "England",
  "seller_name": "Porsche Centre London",
  "seller_type": "Dealer",
  "seller_phone": "+44 20 1234 5678"
}
```

### Use cases

- UK car dealerships tracking competitor pricing for performance and prestige vehicles on PistonHeads
- Automotive market researchers building pricing indices for specialist and enthusiast vehicles in the UK
- Classic and performance car brokers monitoring market availability and price trends by make and model
- Data aggregators feeding specialist vehicle platforms with fresh PistonHeads listings
- Insurers and financiers tracking residual values for prestige vehicles by age and mileage band
- Individual buyers monitoring specific makes and models across the UK by price and location

### Pricing

Pay per result, plus a small monthly base fee. The current rates are shown on this Actor's Store page.

First results are free, so test before subscribing.

### How it works

- Input one or more PistonHeads.com search URLs (any make, model, price, or year filter)
- Every filter in the URL is honoured, because the Actor reads the exact filter set the search page itself resolved
- Listings are paged through the site's own results API, which reports the total number of matches
- `max_pages` caps the depth per search URL at 16 listings per page, and the run stops early once the search runs out of results
- Each listing is fetched and 30+ fields extracted from the page and API response
- Results are available in JSON, CSV, or Excel from the Apify dataset

### Why this scraper

- Uses PistonHeads' own results API for paging, so no page is missed and no page is fetched twice
- Extracts CO2 emissions and fuel consumption, fields most generic scrapers skip but valuable for fleet/tax analysis
- Returns seller phone number per listing, direct contact data that many alternatives omit
- Includes `number_of_owners`, a key value indicator for used car buyers and analysts
- No proxy configuration needed; Apify proxy handles rotation by default

### Input example

```json
{
  "start_urls": [
    { "url": "https://www.pistonheads.com/buy/search?distance=20&price=9000&price=10000&year=2021&year=2025" }
  ],
  "max_pages": 3
}
```

### FAQ

**Does the scraper handle all vehicle types on PistonHeads?**
Yes. Provide any PistonHeads search URL, whether cars, classic vehicles, or project cars.

**Does it include seller contact details?**
Yes. Seller name, type (private or dealer), and phone number are extracted per listing.

**What output formats are available?**
JSON, CSV, and Excel, available from the Apify dataset UI and via REST API.

**Can I limit how many pages it scrapes?**
Yes. `max_pages` caps the depth per search URL, one page being 16 listings. Set it high to take everything a search returns: the run stops as soon as the results are exhausted, so a large value never costs extra time.

**Does it support scheduling?**
Yes. Use Apify's built-in scheduler for daily or weekly automated runs.

**Can I use this via API or MCP?**
Yes. Callable via the Apify REST API and available as an MCP server for AI agents (Claude, ChatGPT, Cursor).

**What if the site structure changes?**
Contact via the Issues tab or reach out at [automationbyexperts.com](https://automationbyexperts.com).

### Use via API or MCP

Call this actor via the Apify REST API or as an MCP server for AI agents (Claude, ChatGPT, Cursor):

```
https://mcp.apify.com/actors/fayoussef/pistonheads
```

Full API docs: <https://docs.apify.com/api/v2>

### Need a custom scraper?

Need PistonHeads data combined with AutoTrader UK or Motors.co.uk, scheduled daily, or pushed to a database? Visit [automationbyexperts.com](https://automationbyexperts.com) for custom builds, retainers, and data-as-a-service.

# Actor input Schema

## `start_urls` (type: `array`):

PistonHeads search result URLs to scrape. Open a search on pistonheads.com, apply your filters, then paste the URL here. All filters in the URL are honoured.

## `max_pages` (type: `integer`):

How many result pages to collect per search URL. One page is 16 listings. The run stops early when the search runs out of results, so a high value never wastes time.

## Actor input object example

```json
{
  "start_urls": [
    {
      "url": "https://www.pistonheads.com/buy/search?price=9000&price=10000&transmission=MAN&year=2021&year=2025"
    }
  ],
  "max_pages": 3
}
```

# 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 = {
    "start_urls": [
        {
            "url": "https://www.pistonheads.com/buy/search?price=9000&price=10000&transmission=MAN&year=2021&year=2025"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fayoussef/pistonheads").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 = { "start_urls": [{ "url": "https://www.pistonheads.com/buy/search?price=9000&price=10000&transmission=MAN&year=2021&year=2025" }] }

# Run the Actor and wait for it to finish
run = client.actor("fayoussef/pistonheads").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 '{
  "start_urls": [
    {
      "url": "https://www.pistonheads.com/buy/search?price=9000&price=10000&transmission=MAN&year=2021&year=2025"
    }
  ]
}' |
apify call fayoussef/pistonheads --silent --output-dataset

```

## MCP server setup

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

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/JCWJsNIoZhas0eEKp/builds/He3AFenwMDufWIDyz/openapi.json