# The Market Scraper — Bonhams Online Car Auctions (`rastriq/themarket-scraper`) Actor

Scrape auction listings from The Market (themarket.co.uk), Bonhams' online auction platform for classic cars. Extract bid prices, estimates, bid counts, reserve status, and auction outcomes. For collector car market tracking.

- **URL**: https://apify.com/rastriq/themarket-scraper.md
- **Developed by:** [Rastriq — Structured data from the world](https://apify.com/rastriq) (community)
- **Categories:** E-commerce, Lead generation
- **Features:** Limited permissions
- **Stats:** 5 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.90 / 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.

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

## The Market Scraper — Bonhams Online Car Auctions: Bids, Estimates & Results

**The Market Scraper** extracts auction data from The Market (themarket.co.uk), the online auction platform for classic and collector cars run by Bonhams. It returns live lots and completed results with current or hammer price, pre-sale estimates, bid counts, reserve status and sold/unsold outcome. Set an optional make and year range, choose how many lots you want, and export JSON, CSV or Excel. Try it first with the default of 10 lots.

### Why scrape The Market auctions?

Weekly timed online auctions create a steady stream of price points for collector cars. The Market Scraper helps:

- **Collectors and dealers:** track live bids and decide where to bid.
- **Valuation and insurance teams:** build comparable sales from completed lots.
- **Auction researchers:** analyse reserve-met rates and estimate versus result by segment.
- **Investors and analysts:** compare online auction prices with traditional live auctions.

### What input does The Market Scraper accept?

| Parameter | Type | Default | Description |
|---|---|---|---|
| `make` | string, nullable | prefill `porsche` | Car make, for example `porsche`, `ferrari`, `mercedes-benz`, `jaguar`. Leave empty for all makes. |
| `year_min` | integer, nullable | none | Earliest model year to include (1886 to 2030). |
| `year_max` | integer, nullable | none | Latest model year to include (1886 to 2030). |
| `max_items` | integer | `100` (prefill `10`) | Maximum listings to extract (1 to 50,000). |
| `max_pages` | integer, nullable | none | Maximum search result pages to process. If empty, `max_items` is the only limit. |
| `proxyConfiguration` | object | prefill Apify Proxy | Datacenter proxy by default; change it only if you have problems. |

Example: Ferraris from 1960 to 1975, up to 50 lots.

```json
{
  "make": "ferrari",
  "year_min": 1960,
  "year_max": 1975,
  "max_items": 50
}
```

Example: everything available, small test.

```json
{
  "max_items": 10
}
```

The Actor reads two sections of the site. Live lots come from the live auctions page (a single page), and completed results are paginated from the results page. Make and year filters are applied client-side after the pages are read, so a narrow filter can mean that more pages have to be processed before `max_items` is reached.

### What data does The Market Scraper return?

| Field | Type | Description |
|---|---|---|
| `id` | string | Listing UUID from The Market |
| `listing_type` | string | `active` or `completed` |
| `url` | string | Direct link to the auction lot |
| `title` | string | Full listing title, for example "2007 Aston Martin DB9" |
| `brand` | string | Car make |
| `model` | string | Car model |
| `model_year` | integer | Year of manufacture |
| `price` | number | Current bid (active) or hammer price (completed), in GBP |
| `price_currency` | string | Currency code, documented as always `GBP` |
| `estimate_low` | number | Low pre-sale estimate, when available |
| `estimate_high` | number | High pre-sale estimate, when available |
| `bid_count` | integer | Number of bids placed |
| `auction_end` | string | Auction end date, for example "22 May 2026" |
| `sold` | string | `sold`, `unsold`, or empty for active lots |
| `reserve_status` | string | `reserve met`, `reserve not met`, `no reserve`, or empty |
| `image_url` | string | Listing thumbnail URL |
| `scraped_at` | datetime | UTC timestamp of extraction |
| `source` | string | Documented as always `themarket.co.uk` |

Estimates, reserve status and `sold` are not present on every lot, so expect empty values. Note that `auction_end` is a text date, not an ISO timestamp.

Illustrative example of one completed lot (values are made up to show the format, not real data):

```json
{
  "id": "00000000-0000-0000-0000-000000000000",
  "listing_type": "completed",
  "url": "https://themarket.co.uk/example-lot",
  "title": "2007 Aston Martin DB9",
  "brand": "Aston Martin",
  "model": "DB9",
  "model_year": 2007,
  "price": 21500,
  "price_currency": "GBP",
  "estimate_low": 20000,
  "estimate_high": 25000,
  "bid_count": 14,
  "auction_end": "22 May 2026",
  "sold": "sold",
  "reserve_status": "reserve met",
  "image_url": "https://themarket.co.uk/example-image.jpg",
  "scraped_at": "2026-10-13T10:00:00+00:00",
  "source": "themarket.co.uk"
}
```

### How much does it cost to scrape The Market?

The Market Scraper uses pay-per-event pricing:

| Event | Price |
|---|---|
| Actor Start (one event per GB of memory, minimum one) | $0.0005 |
| Result (each item in the dataset) | $0.0019 |

Worked example with the default 1,024 MB memory (one start event): 1,000 results = 1,000 × $0.0019 + $0.0005 = **$1.9005**. The default 100 lots cost $0.1905, and a 10-lot test costs $0.0195. Lower `max_items` to cap spend, and check the Pricing tab for discounts on your plan.

### Speed and run time

The previous documentation estimates about 20 listings per minute. The default run timeout is 300 seconds, so for large `max_items` values raise the timeout in the run options. For tracking, schedule weekly runs to follow each new auction cycle.

### How to run it via API

```bash
curl -X POST "https://api.apify.com/v2/acts/rastriq~themarket-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"make":"porsche","year_min":1990,"max_items":100}'
```

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("rastriq/themarket-scraper").call(run_input={
    "make": "porsche",
    "max_items": 100,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["price"], item["reserve_status"])
```

Results can also go to Google Sheets, Make, Zapier or n8n, trigger webhooks on completion, or be called from AI agents through the Apify MCP server.

### FAQ

**Does it return live and finished auctions?** Yes. `listing_type` is `active` for live lots and `completed` for historical results.

**Is `price` the final sale price?** For completed lots it is the hammer price in GBP; for active lots it is the current bid. Check `sold` to separate sold from unsold.

**Why are estimates or reserve status empty?** They are only filled when the lot shows them.

**How do I limit cost?** Set `max_items`, and optionally `max_pages`.

**How far back do results go?** This depends on what the results pages of the site show. Use `max_pages` to read as many pages as you need and check the oldest `auction_end` in your dataset.

**Is it legal?** The Actor reads publicly visible auction pages. You are responsible for respecting the site's terms and applicable data rules.

**Where do I report problems?** Use the Issues tab of the Actor with the run ID.

### Related Rastriq actors

- [Bring a Trailer Scraper](https://apify.com/rastriq/bringatrailer-scraper): classic and collector car auction data
- [Collecting Cars Scraper](https://apify.com/rastriq/collecting-cars-scraper): online car auctions
- [Catawiki Cars Scraper](https://apify.com/rastriq/catawiki-cars-scraper): classic car auctions
- [Classic Driver Scraper](https://apify.com/rastriq/classic-driver-scraper): collector car marketplace

# Actor input Schema

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

Car make to search for on The Market.<br><br>Examples: <code>porsche</code>, <code>ferrari</code>, <code>mercedes-benz</code>, <code>jaguar</code><br><br>Leave empty to scrape all makes.

## `year_min` (type: `integer`):

Earliest model year to include. Leave empty for no lower bound.

## `year_max` (type: `integer`):

Latest model year to include. Leave empty for no upper bound.

## `max_items` (type: `integer`):

Maximum number of listings to extract.<br>Start with <b>10</b> for a quick test, then increase for production runs.

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

Maximum number of search result pages to process. Leave empty to use <b>Max results</b> as the only limit.

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

Select proxies for the scraping run. Datacenter proxy (default) works for most sites and is included in the Apify Free plan.

## Actor input object example

```json
{
  "make": "porsche",
  "max_items": 10,
  "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 = {
    "make": "porsche",
    "max_items": 10,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

# Run the Actor and wait for it to finish
run = client.actor("rastriq/themarket-scraper").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 '{
  "make": "porsche",
  "max_items": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call rastriq/themarket-scraper --silent --output-dataset

```

## MCP server setup

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

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/jgClnKKpdOJKZHzBc/builds/AgQWbdV6pBw6KqUEt/openapi.json