# AutoTrader UK Car Listings Scraper (`automation-lab/autotrader-uk-car-listings-scraper`) Actor

🚗 Extract public AutoTrader UK car listings from a search URL or postcode filters. Get prices, vehicle details, sellers, locations, finance signals, images, badges, and search metadata for inventory and market analysis.

- **URL**: https://apify.com/automation-lab/autotrader-uk-car-listings-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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

## AutoTrader UK Car Listings Scraper

Collect structured vehicle adverts from **AutoTrader.co.uk** using a pasted search URL or buyer-friendly filters.

AutoTrader UK Car Listings Scraper turns public UK car search results into clean JSON, CSV, Excel, XML, or RSS-ready dataset rows. It captures advert IDs, vehicle details, prices, sellers, locations, finance signals, photos, badges, and search metadata without requiring an AutoTrader account.

Use it to compare local inventory, monitor dealer stock, research asking prices, build automotive lead lists, or feed recurring market-data pipelines.

### What does AutoTrader UK Car Listings Scraper do?

The Actor reproduces a public AutoTrader UK car search and paginates its vehicle cards.

It can:

- 🚗 accept a full AutoTrader `/car-search` URL;
- 📍 search from a UK postcode and radius;
- 🔎 filter by make, model, price, year, mileage, and seller type;
- ↕️ sort by relevance, price, distance, recency, or mileage;
- 🧾 export one typed record per unique advert;
- 💷 capture displayed and numeric asking prices;
- 🏪 identify trade and private sellers;
- 🖼️ return high-resolution image URLs and image counts;
- 💳 expose finance availability and returned payment signals;
- 📊 preserve total-result, page, position, and search metadata.

The scraper uses AutoTrader's anonymous public search data. No login, cookies, private API key, or user account is required.

### Why use this AutoTrader UK scraper?

Copying vehicle cards manually is slow and difficult to repeat. Search pages also mix visual presentation with tracking and promotional cards.

This Actor provides:

- **Repeatability** — run the same input on a schedule.
- **Stable IDs** — deduplicate and compare adverts by `advertId`.
- **Typed prices** — use `priceValue` for calculations while retaining displayed `price`.
- **Source links** — every record links back to the public advert.
- **Search provenance** — know which page, position, URL, and search ID produced a row.
- **Bounded costs** — control both listings and search pages.
- **Reliable blocking behaviour** — failed upstream requests are retried with fresh UK sessions rather than silently returning empty data.

### Who is it for?

#### Car dealers and inventory teams

Monitor competing stock, asking prices, finance offers, advert age ordering, and local supply.

#### Automotive analysts

Build repeatable samples by postcode, radius, make, model, year, mileage, and seller type.

#### Pricing and valuation teams

Compare numeric asking prices and price-indicator badges across defined market segments.

#### Lead generation teams

Collect current advert, dealer, location, and seller signals for compliant business research.

#### Developers and data engineers

Send normalized rows to Google Sheets, databases, warehouses, dashboards, webhooks, or custom APIs.

### Input options

You can use either input style.

#### Paste a search URL

Copy the URL after configuring filters on AutoTrader UK:

```json
{
  "searchUrl": "https://www.autotrader.co.uk/car-search?sort=price-asc&postcode=B1%201AA&radius=50&make=Ford&price-to=15000",
  "maxItems": 100,
  "maxPages": 6
}
````

#### Build a structured search

```json
{
  "postcode": "M1 1AE",
  "radius": 25,
  "make": "BMW",
  "model": "3 Series",
  "minYear": 2020,
  "maxMileage": 50000,
  "sellerType": "trade",
  "sort": "newest",
  "maxItems": 100,
  "maxPages": 6
}
```

Structured fields override the matching values from `searchUrl`. This is useful when a pipeline starts from a reusable URL but changes one parameter programmatically.

### Input field reference

| Field | Type | Description |
|---|---|---|
| `searchUrl` | string | Public AutoTrader UK car-search URL |
| `postcode` | string | UK postcode used as the search centre |
| `radius` | integer | Search distance in miles |
| `make` | string | AutoTrader vehicle make |
| `model` | string | AutoTrader model name |
| `minPrice` / `maxPrice` | integer | Asking-price range in GBP |
| `minYear` / `maxYear` | integer | Model-year range |
| `maxMileage` | integer | Maximum advertised mileage |
| `sellerType` | string | `all`, `trade`, or `private` |
| `sort` | string | Relevance, price, distance, newest, or mileage ordering |
| `maxItems` | integer | Maximum unique adverts to save |
| `maxPages` | integer | Maximum search pages to request |

Provide at least `searchUrl` or `postcode`.

### Output data

Each dataset item represents one vehicle advert.

| Field | Meaning |
|---|---|
| `advertId` | AutoTrader advert identifier |
| `url` | Absolute public advert URL |
| `title` | Vehicle make/model title shown on the card |
| `derivative` | Trim, engine, transmission, and body derivative text |
| `make`, `model`, `year` | Structured vehicle identity |
| `condition` | Returned condition, normally `used` or `new` |
| `price` | Displayed price such as `£7,895` |
| `priceValue` | Numeric GBP asking price |
| `vehicleLocation` | Seller location and displayed distance |
| `distanceMiles` | Numeric distance from the search postcode |
| `sellerType` | Trade or private seller signal |
| `dealerId`, `dealerUrl`, `dealerRating` | Dealer signals when returned |
| `imageUrls`, `imageCount` | Listing photos and total photo count |
| `financeAvailable` | Whether the card exposes finance/digital retailing |
| `monthlyFinancePrice` | Displayed monthly payment when returned |
| `financeTermMonths` | Finance term when returned |
| `financeInitialPayment` | Initial payment when returned |
| `badges` | Mileage, registration, price, approval, or other card badges |
| `priceIndicator` | AutoTrader price indicator when present |
| `searchPage`, `position` | Listing placement in this run |
| `totalResults` | Total source matches reported for the search |
| `searchId`, `searchUrl` | Reproducibility metadata |
| `scrapedAt` | UTC extraction timestamp |

Optional fields are omitted when AutoTrader does not return them. The Actor does not manufacture placeholder values.

### Example output

```json
{
  "advertId": "202603050447194",
  "url": "https://www.autotrader.co.uk/car-details/202603050447194",
  "title": "Audi A1",
  "derivative": "1.4 TFSI Sport Sportback Euro 6 (s/s) 5dr",
  "make": "Audi",
  "model": "A1",
  "year": 2016,
  "condition": "used",
  "price": "£7,895",
  "priceValue": 7895,
  "vehicleLocation": "Sutton (10 miles)",
  "distanceMiles": 10,
  "sellerType": "TRADE",
  "dealerRating": 4.9,
  "imageCount": 51,
  "financeAvailable": false,
  "badges": ["Great price", "63,439 miles", "2016 (16 reg)"],
  "priceIndicator": "GREAT",
  "searchPage": 1,
  "totalResults": 25465,
  "scrapedAt": "2026-07-15T02:42:03.592Z"
}
```

### How to scrape AutoTrader UK listings

1. Open the Actor input page.
2. Paste an AutoTrader search URL, or enter a UK postcode.
3. Add vehicle filters if needed.
4. Keep `maxItems` low for the first run.
5. Set `maxPages` as a cost and pagination safety limit.
6. Click **Start**.
7. Open the **Dataset** tab.
8. Export JSON, CSV, Excel, XML, RSS, or HTML.

For recurring monitoring, save the configuration as an Apify Task and attach a schedule.

### How much does it cost to scrape AutoTrader UK listings?

This Actor uses pay-per-event pricing:

- a **$0.005 Run started** event per run;
- one tiered **Item extracted** event per stored vehicle.

| Apify plan | Price per vehicle | 1,000 vehicles plus start |
|---|---:|---:|
| Free | $0.00014272 | about $0.148 |
| Bronze | $0.00012411 | about $0.129 |
| Silver | $0.000096805 | about $0.102 |
| Gold | $0.000074465 | about $0.079 |
| Platinum | $0.000049643 | about $0.055 |
| Diamond | $0.00003475 | about $0.040 |

Residential UK proxy transfer is included in the Actor's operation; users do not configure or buy a separate proxy. Rates were calculated from a representative two-page cloud run and include compute and observed residential transfer with a profitability safety margin.

A low `maxItems` and `maxPages` value is the best way to estimate a specific search. Narrow searches naturally cost less than collecting thousands of adverts.

### Pagination and result limits

AutoTrader reports its own page count and total matches. The Actor stops when any of these occurs:

- `maxItems` unique records have been saved;
- `maxPages` has been reached;
- the source page count has been reached;
- AutoTrader returns no listing cards.

Promotional and non-vehicle inserts are skipped. Duplicate advert IDs are stored only once.

### Reliability and anti-blocking

AutoTrader protects its normal web pages with Cloudflare. This Actor uses the public listing-data request made by the search application rather than rendering every page in a browser.

Requests use:

- UK residential network routing;
- sequential, conservative pagination;
- bounded retries;
- fresh sticky sessions after blocking or transport errors;
- explicit GraphQL error checks;
- non-empty card validation.

If AutoTrader changes its application schema, the run fails visibly instead of reporting a misleading empty success.

### Data quality tips

- Use a valid full UK postcode for location-sensitive searches.
- Prefer AutoTrader's own make and model spelling.
- Paste a working browser search URL for complex filter combinations.
- Keep the URL and structured fields consistent.
- Use `advertId` as the database primary key.
- Compare `scrapedAt` across scheduled runs.
- Retain both `price` and `priceValue`.
- Check `totalResults` before assuming a sample covers the full market.

### Monitoring dealer inventory

Create one Apify Task per market or competitor segment. For example:

- Ford trade listings within 100 miles of Birmingham;
- BMW vehicles from 2020 onward near Manchester;
- private cars below £10,000 around London;
- newest low-mileage electric cars nationwide.

Schedule tasks daily or hourly, then compare `advertId` and `priceValue` with the previous dataset. New IDs indicate fresh adverts; missing IDs can indicate sold or withdrawn stock; price changes support competitive analysis.

### Integrations

#### Google Sheets

Use the Google Sheets integration to append vehicle rows for pricing and inventory teams.

#### Webhooks

Send a run-finished webhook to n8n, Make, Zapier, or your backend. Fetch the dataset using `defaultDatasetId`.

#### Databases and warehouses

Load JSON or CSV into PostgreSQL, BigQuery, Snowflake, Redshift, or object storage. Use `advertId` for upserts.

#### Slack and email alerts

Trigger notifications when a scheduled run finds a target make, a price below a threshold, or a new private advert.

### API usage

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/autotrader-uk-car-listings-scraper').call({
  postcode: 'SW1A 1AA',
  radius: 25,
  make: 'Toyota',
  maxItems: 50,
  maxPages: 3,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/autotrader-uk-car-listings-scraper').call(run_input={
    'postcode': 'M1 1AE',
    'radius': 25,
    'make': 'BMW',
    'maxItems': 50,
    'maxPages': 3,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~autotrader-uk-car-listings-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "postcode": "B1 1AA",
    "radius": 50,
    "sellerType": "trade",
    "maxItems": 25,
    "maxPages": 2
  }'
```

After completion, fetch items from the run's `defaultDatasetId`.

### Use with Apify MCP

Connect AI assistants to Apify MCP with this Actor enabled.

#### Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/autotrader-uk-car-listings-scraper"
```

#### Claude Desktop and Cursor

Add this server to the app's MCP JSON configuration:

```json
{
  "mcpServers": {
    "apify-autotrader-uk": {
      "url": "https://mcp.apify.com?tools=automation-lab/autotrader-uk-car-listings-scraper"
    }
  }
}
```

#### VS Code

Add the same actor-scoped HTTP URL through the **MCP: Add Server** command, then authenticate with Apify when prompted.

Example prompts:

- “Scrape 50 recent BMW listings within 25 miles of Manchester and summarize the median asking price.”
- “Find trade Ford listings below £15,000 near Birmingham and group them by model year.”
- “Compare this week's advert IDs with last week's dataset and list new inventory.”

The MCP server works with Claude Desktop, Claude Code, Cursor, and other compatible clients.

### Scheduling recurring runs

1. Save a tested input as an Apify Task.
2. Open **Schedules** in Apify Console.
3. Choose an interval and timezone.
4. Attach a webhook or downstream integration.
5. Upsert results by `advertId`.

Avoid unnecessarily frequent runs when the target market changes slowly. A daily schedule is often enough for inventory intelligence.

### Legal and responsible use

This Actor accesses public vehicle search results without login. Scraping legality depends on jurisdiction, purpose, volume, storage, and downstream use.

Users are responsible for:

- complying with applicable laws and AutoTrader terms;
- respecting intellectual property and database rights;
- avoiding harmful or excessive collection;
- handling seller information lawfully;
- applying UK GDPR and data-retention requirements where relevant;
- using the output for legitimate analysis and automation.

The Actor does not submit forms, contact sellers, bypass account controls, or access private user data.

### Limitations

- The initial version extracts search-card data, not every detail-page specification.
- Dealer contact details and advert descriptions are not guaranteed.
- Some finance fields are absent when the search card does not expose a quote.
- Search results and ranking can change between runs.
- AutoTrader may cap the number of browsable pages for very broad searches.
- URL filters added by AutoTrader in the future may require an Actor update.
- Only the AutoTrader UK car-search channel is supported in this version.

### Troubleshooting

#### Why did my run return no vehicles?

Open the same search URL in AutoTrader and confirm that it has matches. Check postcode spelling, radius, make/model naming, and conflicting year or price limits.

#### Why did the run fail instead of returning an empty dataset?

The Actor intentionally fails after bounded retries when AutoTrader blocks or changes the data contract. This prevents false “successful” monitoring runs with zero records. Retry later or report the run ID if the issue persists.

#### Why does the URL radius differ from my result?

A structured `radius` field overrides the radius in `searchUrl`. Remove the structured field when the pasted URL should be authoritative.

#### Why are some finance fields missing?

AutoTrader only returns finance details for eligible adverts and cards. `financeAvailable` remains the reliable boolean signal.

### FAQ

#### Does it require an AutoTrader login?

No. The supported search-listing workflow is anonymous.

#### Can I paste any AutoTrader URL?

Use a public `autotrader.co.uk/car-search` URL. Advert detail URLs are not input targets in this release.

#### Does it scrape vans, bikes, caravans, or trucks?

No. Version 1 supports the UK cars channel only.

#### Can it collect thousands of listings?

Yes, subject to source pagination and your `maxItems`/`maxPages` limits. Start small and scale after reviewing output and cost.

#### Are duplicates removed?

Yes. Advert IDs are deduplicated within each run.

#### Can I export to Excel?

Yes. Apify datasets support Excel, CSV, JSON, XML, RSS, and HTML exports.

#### Can I run it on a schedule?

Yes. Save the input as an Apify Task and attach an Apify schedule.

### Related scrapers

- [AutoTrader Canada Vehicle Listings Scraper](https://apify.com/automation-lab/autotrader-canada-vehicle-listings-scraper) — use this for Canadian AutoTrader inventory.
- Browse other actors from [automation-lab](https://apify.com/automation-lab) for complementary vehicle, dealer, marketplace, and business data workflows.

### Support

If a run fails repeatedly, share the Apify run URL, input, expected result, and a public AutoTrader search URL. This makes source changes and edge cases faster to reproduce.

For feature requests, describe the missing field or workflow and whether it is visible on the search card or only on the advert detail page.

# Actor input Schema

## `searchUrl` (type: `string`):

A public https://www.autotrader.co.uk/car-search URL. Structured fields below override matching URL filters.

## `postcode` (type: `string`):

Search centre, for example SW1A 1AA. Required only when no search URL is supplied.

## `radius` (type: `integer`):

Maximum distance from the postcode.

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

AutoTrader make name, for example BMW, Ford, or Toyota.

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

Model name used by AutoTrader.

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

Exclude vehicles priced below this amount.

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

Exclude vehicles priced above this amount.

## `minYear` (type: `integer`):

Oldest model year to include.

## `maxYear` (type: `integer`):

Newest model year to include.

## `maxMileage` (type: `integer`):

Maximum advertised vehicle mileage.

## `sellerType` (type: `string`):

Include all sellers or only trade/private adverts.

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

AutoTrader ordering applied to every page.

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

Stop after this many unique vehicle adverts.

## `maxPages` (type: `integer`):

Safety limit for pagination. Each page uses one residential request in normal operation.

## Actor input object example

```json
{
  "searchUrl": "https://www.autotrader.co.uk/car-search?sort=relevance&postcode=SW1A%201AA&radius=10",
  "postcode": "SW1A 1AA",
  "radius": 10,
  "sellerType": "all",
  "maxItems": 10,
  "maxPages": 2
}
```

# Actor output Schema

## `overview` (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 = {
    "searchUrl": "https://www.autotrader.co.uk/car-search?sort=relevance&postcode=SW1A%201AA&radius=10",
    "postcode": "SW1A 1AA",
    "radius": 10,
    "maxItems": 10,
    "maxPages": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/autotrader-uk-car-listings-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 = {
    "searchUrl": "https://www.autotrader.co.uk/car-search?sort=relevance&postcode=SW1A%201AA&radius=10",
    "postcode": "SW1A 1AA",
    "radius": 10,
    "maxItems": 10,
    "maxPages": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/autotrader-uk-car-listings-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 '{
  "searchUrl": "https://www.autotrader.co.uk/car-search?sort=relevance&postcode=SW1A%201AA&radius=10",
  "postcode": "SW1A 1AA",
  "radius": 10,
  "maxItems": 10,
  "maxPages": 2
}' |
apify call automation-lab/autotrader-uk-car-listings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/autotrader-uk-car-listings-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AutoTrader UK Car Listings Scraper",
        "description": "🚗 Extract public AutoTrader UK car listings from a search URL or postcode filters. Get prices, vehicle details, sellers, locations, finance signals, images, badges, and search metadata for inventory and market analysis.",
        "version": "0.1",
        "x-build-id": "QYD90DY3WIjMae7yI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~autotrader-uk-car-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-autotrader-uk-car-listings-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/automation-lab~autotrader-uk-car-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-autotrader-uk-car-listings-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/automation-lab~autotrader-uk-car-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-autotrader-uk-car-listings-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": {
                    "searchUrl": {
                        "title": "AutoTrader car-search URL",
                        "type": "string",
                        "description": "A public https://www.autotrader.co.uk/car-search URL. Structured fields below override matching URL filters."
                    },
                    "postcode": {
                        "title": "UK postcode",
                        "type": "string",
                        "description": "Search centre, for example SW1A 1AA. Required only when no search URL is supplied."
                    },
                    "radius": {
                        "title": "Radius (miles)",
                        "minimum": 1,
                        "maximum": 1500,
                        "type": "integer",
                        "description": "Maximum distance from the postcode."
                    },
                    "make": {
                        "title": "Make",
                        "type": "string",
                        "description": "AutoTrader make name, for example BMW, Ford, or Toyota."
                    },
                    "model": {
                        "title": "Model",
                        "type": "string",
                        "description": "Model name used by AutoTrader."
                    },
                    "minPrice": {
                        "title": "Minimum price (£)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Exclude vehicles priced below this amount."
                    },
                    "maxPrice": {
                        "title": "Maximum price (£)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Exclude vehicles priced above this amount."
                    },
                    "minYear": {
                        "title": "Minimum year",
                        "minimum": 1900,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Oldest model year to include."
                    },
                    "maxYear": {
                        "title": "Maximum year",
                        "minimum": 1900,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Newest model year to include."
                    },
                    "maxMileage": {
                        "title": "Maximum mileage",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum advertised vehicle mileage."
                    },
                    "sellerType": {
                        "title": "Seller type",
                        "enum": [
                            "all",
                            "trade",
                            "private"
                        ],
                        "type": "string",
                        "description": "Include all sellers or only trade/private adverts.",
                        "default": "all"
                    },
                    "sort": {
                        "title": "Sort listings by",
                        "enum": [
                            "relevance",
                            "price-asc",
                            "price-desc",
                            "distance",
                            "newest",
                            "mileage"
                        ],
                        "type": "string",
                        "description": "AutoTrader ordering applied to every page."
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Stop after this many unique vehicle adverts.",
                        "default": 20
                    },
                    "maxPages": {
                        "title": "Maximum search pages",
                        "minimum": 1,
                        "maximum": 250,
                        "type": "integer",
                        "description": "Safety limit for pagination. Each page uses one residential request in normal operation.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```