# Carzone Used Cars Scraper (`automation-lab/carzone-ie-used-car-listings-scraper`) Actor

Search Carzone.ie and export listing IDs, vehicle details, asking prices, sellers, counties, images, and URLs for Irish inventory monitoring.

- **URL**: https://apify.com/automation-lab/carzone-ie-used-car-listings-scraper.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 car listing saveds

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

## Carzone Used Cars Scraper

Export **carzone used cars** as structured records for Irish inventory research and asking-price monitoring.
Search by keywords or make/model, or paste a filtered Carzone.ie search URL.
Each saved row includes stable listing identity, vehicle details, price, seller, county, images, and the canonical listing URL.

The Actor uses Carzone's public search data rather than opening every detail page.
That keeps runs focused on the fields needed for repeatable inventory snapshots.
No Carzone login or cookies are required.

### What can you do with this Carzone scraper?

- Export a current Irish used-car inventory sample to JSON, CSV, Excel, or XML.
- Compare asking prices across makes and models.
- Collect stable listing IDs for new-listing and removed-listing checks downstream.
- Feed dealer inventory into a spreadsheet, warehouse, dashboard, or analysis notebook.
- Schedule the same input daily or weekly, then compare datasets in your own workflow.
- Preserve the source search URL and extraction time with every record.

The Actor creates snapshots; it does not maintain price history or send alerts by itself.
Use Apify schedules, integrations, webhooks, or your own database to compare runs.

### Who is this Actor for?

**Automotive analysts** can build market samples by make, model, fuel type, or search phrase.

**Dealers and inventory teams** can compare public supply and asking prices against a stable search scope.

**Data teams** can load normalized listing rows into BI tools without maintaining Carzone page parsers.

**Researchers** can create reproducible source snapshots containing identifiers and provenance.

**Automation builders** can trigger bounded Carzone exports from the API, MCP clients, schedules, and webhooks.

### What data does it extract?

| Field | Meaning |
| --- | --- |
| `listingId` | Stable public Carzone listing identifier |
| `title` | Seller-provided advert title |
| `make`, `model`, `variant` | Vehicle identity and derivative/trim |
| `year` | Registration or model year |
| `mileage`, `mileageUnit` | Mileage normalized to kilometres when exposed |
| `fuelType`, `transmission` | Public powertrain and gearbox values |
| `engineSizeLitres`, `engineSizeCc` | Engine size when present in search data |
| `price`, `currency` | Asking price in EUR |
| `priceOnApplication` | Whether price requires contacting the seller |
| `sellerType`, `sellerName`, `sellerId` | Public seller/dealer fields |
| `town`, `county`, `location` | Best available Irish location fields |
| `imageUrl`, `imageUrls` | Primary and all public listing image URLs |
| `url` | Canonical Carzone listing URL |
| `listingType` | Natural or promoted search placement group |
| `searchUrl` | Search scope that produced the row |
| `scrapedAt` | ISO 8601 snapshot time |

Nullable fields remain `null` when Carzone does not expose them.
The Actor does not invent hidden seller names, locations, prices, or vehicle specifications.

### How to scrape Carzone used cars

1. Open the Actor input page.
2. Enter a free-text `query`, a `make` and optional `model`, or one or more `startUrls`.
3. Set `maxItems` to the largest number of unique listings you need.
4. Keep Apify Proxy enabled unless you have already verified your own route to Carzone.
5. Click **Start**.
6. Inspect the default dataset and export it in your preferred format.
7. Save the task or schedule it when you need repeatable snapshots.

A broad run with no query, make, model, or URL starts from all used-car inventory.
Start with a small `maxItems` while confirming your workflow.

### Input parameters

#### `query`

Optional free-text search such as `hybrid SUV`.
It maps to Carzone's public keyword search.
Do not combine it with a make/model unless that combination is meaningful on Carzone.

#### `make` and `model`

Use exact display names such as `Toyota` and `Corolla`.
`model` requires `make` when explicit URLs are not provided.
Make-only searches are supported.

#### `startUrls`

Accepts up to 50 real Carzone search-result URLs:

```json
{
  "startUrls": [
    { "url": "https://www.carzone.ie/used-cars/toyota/corolla" }
  ],
  "maxItems": 100
}
```

Supported paths begin with `/used-cars` or `/search`.
Filtered query parameters are preserved.
Individual `/fpa/` listing detail URLs and non-Carzone domains fail validation.
When URLs are present, they take precedence over `query`, `make`, and `model`.

#### `maxItems`

The global cap across every supplied search, from 1 to 10,000.
Duplicate listing IDs do not consume additional items.
Pagination stops as soon as the cap is reached.

#### `proxyConfiguration`

Apify Proxy is enabled by default because Carzone blocks some direct cloud and development IPs.
The Actor keeps one healthy proxy session across pages and rotates identity only after a blocked or transient response.
Choose custom proxy settings only when your Apify plan supports them and your use case requires them.

### Example input

Search for a bounded hybrid SUV sample:

```json
{
  "query": "hybrid SUV",
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

Monitor one make with a larger repeatable snapshot:

```json
{
  "make": "BMW",
  "maxItems": 250,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

### Example output

This shortened record reflects real current Actor output:

```json
{
  "listingId": "4497292",
  "title": "Kia Sportage BLACK EDITION HYBRID",
  "make": "Kia",
  "model": "Sportage",
  "variant": "BLACK EDITION HYBRID",
  "year": 2026,
  "mileage": 10,
  "mileageUnit": "km",
  "fuelType": "Petrol Hybrid",
  "transmission": "Automatic",
  "price": 50500,
  "currency": "EUR",
  "priceOnApplication": false,
  "sellerName": "Newgate Motor Group",
  "county": "Meath",
  "imageUrl": "https://c0.carsie.ie/...jpg",
  "url": "https://www.carzone.ie/used-cars/kia/sportage/fpa/4497292",
  "listingType": "Natural",
  "searchUrl": "https://www.carzone.ie/search?keywords=hybrid+SUV",
  "scrapedAt": "2026-09-15T14:42:00.000Z"
}
```

Image URLs are shortened only in this documentation example.
Dataset rows contain the full public URL.

### How much does it cost to scrape Carzone used cars?

The Actor uses pay per event pricing:

- **$0.005** once when a run starts.
- One `item` event for each unique normalized listing saved.
- Item prices depend on your Apify plan: $0.0023 on FREE, $0.002 on BRONZE, $0.00156 on SILVER, and $0.0012 on GOLD, PLATINUM, or DIAMOND.

Examples using the FREE tier are approximately:

| Saved listings | Estimated Actor charge |
| ---: | ---: |
| 10 | $0.028 |
| 100 | $0.235 |
| 1,000 | $2.305 |

A valid empty search pays only the one-time start event.
Duplicates, malformed source records, and failed requests are not charged as items.
Apify displays the exact charge for every completed run.

### Inventory and price-monitoring workflow

1. Create a task with a stable keyword, make/model, or filtered Carzone URL.
2. Set a consistent `maxItems` large enough for the target inventory.
3. Schedule the task daily or weekly in Apify Console.
4. Send each dataset to Google Sheets, Make, Zapier, a webhook, or your warehouse.
5. Join snapshots by `listingId`.
6. Compare `price` and presence across snapshot dates.

A new ID indicates newly observed inventory.
A changed price indicates a changed public asking price.
A missing ID can mean removal, sale, expiry, or a changed search scope; verify before drawing conclusions.

### Pagination, duplicates, and ordering

Carzone groups natural and promoted placements in each API page.
The same listing can appear in more than one group or search.
The Actor deduplicates globally by `listingId` while preserving the first encountered placement.

Pages are requested sequentially for a coherent search snapshot.
The Actor stops on source exhaustion, an empty page, or `maxItems`.
Carzone controls result ranking, promoted placements, and total page counts.

### Reliability and retry behavior

Every response must be HTTP 200 and match the expected Carzone JSON shape.
A challenge page is treated as an error, not as an empty result.

Network failures, HTTP 403, 408, 429, and temporary server errors trigger a fresh proxy identity and exponential backoff.
Each page has at most three total attempts.
Other deterministic HTTP failures stop the run rather than retrying blindly.

A valid no-result search succeeds with zero rows.
Malformed inputs and exhausted upstream retries fail the run with a non-zero status.

### Export and integration options

The default dataset works with:

- JSON, JSONL, CSV, Excel, XML, and RSS exports;
- Apify schedules and webhooks;
- Google Sheets integrations;
- Make and Zapier scenarios;
- REST API clients;
- `apify-client` for JavaScript and Python;
- Apify MCP for AI-assisted workflows.

For tabular tools, select the `overview` dataset view or export all fields for deeper analysis.
Do not download images unless your downstream job actually needs the media bytes.

### Run with the REST API

Replace `<APIFY_TOKEN>` with your Apify API token:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~carzone-ie-used-car-listings-scraper/runs?token=<APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"make":"Toyota","model":"Corolla","maxItems":50}'
```

The response contains the run ID and default dataset ID.
Wait for a terminal run status before reading all dataset items.
Keep tokens in secrets or environment variables, not source files.

### Run with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/carzone-ie-used-car-listings-scraper').call({
    query: 'hybrid SUV',
    maxItems: 100,
    proxyConfiguration: { useApifyProxy: true },
});

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

### Run with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/carzone-ie-used-car-listings-scraper').call(
    run_input={
        'make': 'BMW',
        'maxItems': 100,
        'proxyConfiguration': {'useApifyProxy': True},
    }
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use this Actor through MCP

#### Claude Code setup

Add the remote Apify MCP server in Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/carzone-ie-used-car-listings-scraper"
```

#### Claude Desktop, Cursor, and VS Code setup

Claude Desktop, Cursor, and VS Code can use this equivalent MCP server configuration:

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

Example prompts:

- “Run the Carzone scraper for 25 Toyota Corolla listings and summarize median asking price.”
- “Export 50 hybrid SUV records from Carzone and group them by county.”
- “Collect a BMW inventory snapshot and return the dataset URL.”

The AI client can start runs and read Actor outputs subject to your Apify credentials and tool permissions.

### Legality and responsible use

Carzone.ie is a third-party website.
Use the Actor only for lawful purposes and public data you are entitled to process.
Review Carzone's terms, robots guidance, and applicable privacy, database, copyright, and consumer-protection rules for your jurisdiction.

Avoid collecting more data than your legitimate purpose requires.
Do not use output for harassment, discrimination, unwanted contact, or attempts to identify private individuals.
Respect removal requests and retention requirements that apply to your workflow.
This documentation is not legal advice.

### Limitations

- The Actor covers public Carzone search listings, not account-only or seller-private data.
- It does not maintain history, detect changes, or send alerts internally.
- It does not fetch detail pages, so fields absent from search data remain null.
- Carzone can change parameter names, response fields, ranking, or availability.
- Seller names and precise towns may be absent, especially for some private listings.
- Asking price is not a completed-sale price or valuation.
- Search ranking can include promoted listings; use `listingType` when analyzing placement.
- Very broad inventories take longer and can change while pagination is in progress.

### Troubleshooting

#### Why did my run return zero rows?

Confirm the same query or URL currently returns results on Carzone.
A valid nonsense or over-constrained query correctly produces an empty dataset.
Check that explicit URLs use `/used-cars` or `/search`, not an individual `/fpa/` detail page.

#### Why did the run fail with a Carzone HTTP error?

Keep Apify Proxy enabled and retry once after checking Apify and Carzone availability.
The Actor already performs bounded fresh-session retries for transient failures, so repeated failure usually indicates an upstream change or outage rather than normal emptiness.

#### Why is a field null?

Carzone does not publish every field for every seller and listing.
The Actor preserves nullability instead of guessing.
Use `listingId` and `url` as the strongest identifiers.

#### Why are fewer rows saved than requested?

The source may have fewer unique matching listings, and duplicates across featured and natural groups are removed.
Multiple search URLs also share one global `maxItems` cap.

### FAQ

#### Does this require a Carzone account?

No. It reads public search data and does not accept Carzone credentials.

#### Can I supply multiple search URLs?

Yes, up to 50.
They are processed in order and deduplicated into one default dataset.

#### Can I search all used cars?

Yes. Leave query, make, model, and URLs empty, then choose a practical `maxItems`.

#### Does it download images?

No. It exports public image URLs, avoiding unnecessary transfer and storage.

#### Can it detect a sold car?

Not by itself.
Compare stable IDs across scheduled snapshots and treat disappearance as a signal that still needs verification.

#### Is the output suitable for a spreadsheet?

Yes. Use the overview view for common fields or export the complete dataset as CSV or Excel.

### Related automotive Actors

- [AutoTempest Car Listings Scraper](https://apify.com/automation-lab/autotempest-car-listings-scraper) for aggregated vehicle-search records from another source.
- [Cars.com Vehicle Listings Scraper](https://apify.com/automation-lab/cars-com-vehicle-listings-scraper) for United States marketplace research.
- [CarGurus Vehicle Listings Scraper](https://apify.com/automation-lab/cargurus-vehicle-listings-scraper) for another vehicle-listing workflow.

These Actors use different sources and schemas.
Choose the source that matches your market and compare terms before combining datasets.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/carzone-ie-used-car-listings-scraper/changelog.md

# Actor input Schema

## `query` (type: `string`):

Optional free-text Carzone search, for example hybrid SUV. Leave empty to browse all used cars or combine make and model below.

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

Optional exact Carzone make name, such as Toyota, BMW, Ford, or Volkswagen.

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

Optional exact Carzone model name. A make is required when this field is used without explicit URLs.

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

Optional Carzone.ie used-cars or search-result URLs, including filters already selected on Carzone. Listing detail URLs are not accepted.

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

Maximum number of unique used-car records saved across all searches.

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

Apify Proxy is enabled by default because Carzone blocks some direct cloud and development IPs. The Actor rotates sessions only after a blocked or transient response.

## Actor input object example

```json
{
  "query": "hybrid SUV",
  "make": "Toyota",
  "model": "Corolla",
  "startUrls": [
    {
      "url": "https://www.carzone.ie/used-cars/toyota/corolla"
    }
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Open the default dataset with the overview view applied.

# 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 = {
    "query": "hybrid SUV",
    "make": "Toyota",
    "model": "Corolla",
    "startUrls": [
        {
            "url": "https://www.carzone.ie/used-cars/toyota/corolla"
        }
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/carzone-ie-used-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 = {
    "query": "hybrid SUV",
    "make": "Toyota",
    "model": "Corolla",
    "startUrls": [{ "url": "https://www.carzone.ie/used-cars/toyota/corolla" }],
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/carzone-ie-used-car-listings-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 '{
  "query": "hybrid SUV",
  "make": "Toyota",
  "model": "Corolla",
  "startUrls": [
    {
      "url": "https://www.carzone.ie/used-cars/toyota/corolla"
    }
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call automation-lab/carzone-ie-used-car-listings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/carzone-ie-used-car-listings-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/HfVw7tXo9q90UvTZQ/builds/pPi6aAQLxNlf9Ratj/openapi.json