# Autohero Cars Scraper (`automation-lab/autohero-cars-scraper`) Actor

🚗 Extract Autohero used-car listings, prices, mileage, specs, images, and URLs from public country search pages for market research.

- **URL**: https://apify.com/automation-lab/autohero-cars-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.md):

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

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

## Autohero Cars Scraper

Extract Autohero used-car listings from public country search pages.

Autohero Cars Scraper saves prices, mileage, year, trim, fuel, transmission, images, listing URLs, and country metadata.

Use it for inventory monitoring, market pricing research, dealer benchmarking, and lead workflows.

### What does Autohero Cars Scraper do?

Autohero Cars Scraper collects vehicle cards from Autohero search result pages.

It works with public Autohero country URLs such as Germany, France, Netherlands, Spain, Italy, and Poland.

The actor parses server-rendered listing HTML.

No login is required for the supported search pages.

Each dataset row represents one car listing.

### Who is it for?

Used-car dealers can monitor Autohero inventory in their markets.

Pricing analysts can compare mileage, model year, fuel type, and asking price.

Market researchers can build recurring country snapshots.

Lead-generation teams can export fresh listing URLs.

Data teams can feed normalized vehicle rows into BI dashboards.

### Why use this Autohero scraper?

🚗 It is focused on Autohero car cards.

💶 It returns numeric prices and monthly payment text.

📊 It captures mileage, year, fuel, and transmission.

🔗 It includes direct listing URLs for follow-up.

🌍 It supports multiple country search URLs in one run.

### What data can you extract?

| Field | Description |
| --- | --- |
| `title` | Vehicle card title |
| `make` | First token from the title |
| `model` | Remaining title text |
| `trim` | Autohero subtitle or trim |
| `price` | Numeric asking price |
| `priceText` | Original displayed price text |
| `monthlyPrice` | Numeric monthly payment when shown |
| `monthlyPriceText` | Original monthly payment text |
| `year` | Registration/model year from specs |
| `fuelType` | Fuel type from specs |
| `mileageKm` | Numeric mileage in kilometers |
| `transmission` | Gearbox/transmission text |
| `co2Emissions` | Displayed CO2 value |
| `fuelConsumption` | Displayed fuel consumption |
| `badges` | Visible badges such as first owner or low mileage |
| `imageUrl` | Main listing image URL |
| `listingUrl` | Autohero listing URL |
| `country` | Autohero country path |
| `sourceUrl` | Search URL that produced the listing |
| `scrapedAt` | ISO timestamp for the run |

### How much does it cost to scrape Autohero car listings?

This actor uses pay-per-event pricing.

There is a small start fee per run.

There is a per-listing charge for every car saved to the dataset.

Use a low `maxItems` value for test runs.

Increase the limit only after your input URLs return the fields you need.

### How to use it

1. Open the actor on Apify.

2. Add one or more Autohero search URLs.

3. Set `maxItems` to the number of car rows you want.

4. Keep deduplication enabled unless you want duplicates across country URLs.

5. Start the run.

6. Export the dataset as JSON, CSV, Excel, or via API.

### Input

The main input is `startUrls`.

Each URL should be an Autohero country or filtered search page.

Examples:

```json
{
  "startUrls": [
    { "url": "https://www.autohero.com/de/search/" },
    { "url": "https://www.autohero.com/fr/search/" }
  ],
  "maxItems": 100,
  "deduplicate": true
}
````

### Output

The actor stores one vehicle per dataset item.

Example output:

```json
{
  "title": "Toyota Yaris Cross",
  "make": "Toyota",
  "model": "Yaris Cross",
  "trim": "1.5 Hybrid AWD-i Premiere Edition",
  "price": 29250,
  "priceText": "29.250 €",
  "monthlyPrice": 402,
  "monthlyPriceText": "402 € mtl.",
  "year": 2024,
  "fuelType": "Hybrid",
  "mileageKm": 7332,
  "transmission": "Automatikgetriebe",
  "listingUrl": "https://www.autohero.com/de/toyota-yaris-cross/id/.../",
  "country": "de"
}
```

### Tips for best results

Copy URLs directly from Autohero after applying filters.

Use separate URLs for separate countries.

Keep `deduplicate` enabled for multi-country dashboards.

Use `maxItems` to control spend.

Schedule the actor daily or weekly for monitoring.

### Integrations

Send the dataset to Google Sheets for dealer reporting.

Push output to BigQuery for market analysis.

Use webhooks to notify a CRM when new listings appear.

Connect with Make or Zapier for low-code inventory workflows.

Use Apify API clients for automated ingestion.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/autohero-cars-scraper').call({
  startUrls: [{ url: 'https://www.autohero.com/de/search/' }],
  maxItems: 100,
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/autohero-cars-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.autohero.com/de/search/'}],
    'maxItems': 100,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~autohero-cars-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.autohero.com/de/search/"}],"maxItems":100}'
```

### MCP usage

Use the Apify MCP server with Claude Desktop or Claude Code.

MCP URL:

`https://mcp.apify.com/?tools=automation-lab/autohero-cars-scraper`

Claude Code setup:

```bash
claude mcp add apify-autohero "https://mcp.apify.com/?tools=automation-lab/autohero-cars-scraper"
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-autohero": {
      "url": "https://mcp.apify.com/?tools=automation-lab/autohero-cars-scraper"
    }
  }
}
```

Example prompts:

- "Scrape 100 Autohero Germany cars and summarize price by fuel type."

- "Run Autohero Cars Scraper for Germany and France and find low-mileage hybrids."

- "Export Autohero listings to a spreadsheet-ready table."

### Scheduling

Create an Apify schedule to run the scraper every day.

Use the same filtered URLs each time.

Compare datasets over time to detect inventory and price changes.

### Monitoring workflow

Store each run's dataset ID.

Join by `listingUrl`.

Detect new cars, removed cars, and price movements.

Alert your team when matching cars appear.

### Supported pages

The actor targets public Autohero search pages.

It supports country paths such as `/de/search/`, `/fr/search/`, `/nl/search/`, `/es/search/`, `/it/search/`, and `/pl/search/`.

Filtered URLs are supported when Autohero serves listing cards in the initial HTML.

### Limitations

The actor does not crawl detail pages in version 0.1.

It extracts fields visible on search result cards.

If Autohero changes its card selectors, extraction may need an update.

Availability can change between a scrape and a user's visit.

### Troubleshooting

If you receive fewer rows than expected, increase the number of country or filtered search URLs.

If a filtered URL returns zero rows, open it in a browser and confirm Autohero shows listings.

If prices look localized, use `priceText` alongside numeric `price` for display.

### Legality

This actor extracts publicly available listing information.

You are responsible for using the data lawfully.

Respect Autohero's terms, privacy rules, and applicable regulations.

Do not scrape personal data or use output for unlawful profiling.

### Related scrapers

Explore other Automation Lab actors at https://apify.com/automation-lab/.

Useful adjacent actors may include car marketplace scrapers, e-commerce scrapers, and price monitoring tools.

### Support

Open an Apify issue if a supported Autohero search URL stops returning listings.

Include your run ID and input URL.

A small reproducible input helps us fix selector changes quickly.

### Changelog

Version 0.1 extracts public Autohero search-card listings from supplied country/search URLs.

### FAQ

#### Can I scrape multiple countries?

Yes. Add multiple Autohero country URLs to `startUrls`.

#### Does it require proxies?

The initial implementation uses direct HTTP requests because Autohero search pages returned public SSR HTML during validation.

#### Can I get listing detail-page fields?

Not in v0.1. Detail-page crawling can be added later if demand justifies the extra cost.

#### Can I monitor prices over time?

Yes. Schedule recurring runs and compare rows by `listingUrl`.

#### Why do some fields show null?

Autohero does not display every spec on every card. Missing card fields are returned as `null`.

# Actor input Schema

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

Autohero country or filtered search URLs to scrape. Use URLs such as https://www.autohero.com/de/search/ or a filtered search page copied from Autohero.

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

Maximum number of vehicle listing records to save across all supplied Autohero URLs.

## `deduplicate` (type: `boolean`):

Skip duplicate vehicles when the same listing appears in more than one supplied search URL.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.autohero.com/de/search/"
    },
    {
      "url": "https://www.autohero.com/fr/search/"
    },
    {
      "url": "https://www.autohero.com/nl/search/"
    },
    {
      "url": "https://www.autohero.com/es/search/"
    },
    {
      "url": "https://www.autohero.com/it/search/"
    },
    {
      "url": "https://www.autohero.com/pl/search/"
    }
  ],
  "maxItems": 20,
  "deduplicate": true
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://www.autohero.com/de/search/"
        },
        {
            "url": "https://www.autohero.com/fr/search/"
        },
        {
            "url": "https://www.autohero.com/nl/search/"
        },
        {
            "url": "https://www.autohero.com/es/search/"
        },
        {
            "url": "https://www.autohero.com/it/search/"
        },
        {
            "url": "https://www.autohero.com/pl/search/"
        }
    ],
    "maxItems": 20,
    "deduplicate": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/autohero-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 = {
    "startUrls": [
        { "url": "https://www.autohero.com/de/search/" },
        { "url": "https://www.autohero.com/fr/search/" },
        { "url": "https://www.autohero.com/nl/search/" },
        { "url": "https://www.autohero.com/es/search/" },
        { "url": "https://www.autohero.com/it/search/" },
        { "url": "https://www.autohero.com/pl/search/" },
    ],
    "maxItems": 20,
    "deduplicate": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/autohero-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 '{
  "startUrls": [
    {
      "url": "https://www.autohero.com/de/search/"
    },
    {
      "url": "https://www.autohero.com/fr/search/"
    },
    {
      "url": "https://www.autohero.com/nl/search/"
    },
    {
      "url": "https://www.autohero.com/es/search/"
    },
    {
      "url": "https://www.autohero.com/it/search/"
    },
    {
      "url": "https://www.autohero.com/pl/search/"
    }
  ],
  "maxItems": 20,
  "deduplicate": true
}' |
apify call automation-lab/autohero-cars-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Autohero Cars Scraper",
        "description": "🚗 Extract Autohero used-car listings, prices, mileage, specs, images, and URLs from public country search pages for market research.",
        "version": "0.1",
        "x-build-id": "FXvLYaIlDbNM8c5Vh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~autohero-cars-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-autohero-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/automation-lab~autohero-cars-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-autohero-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/automation-lab~autohero-cars-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-autohero-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Autohero search URLs",
                        "type": "array",
                        "description": "Autohero country or filtered search URLs to scrape. Use URLs such as https://www.autohero.com/de/search/ or a filtered search page copied from Autohero.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum cars",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of vehicle listing records to save across all supplied Autohero URLs.",
                        "default": 20
                    },
                    "deduplicate": {
                        "title": "Deduplicate by listing URL",
                        "type": "boolean",
                        "description": "Skip duplicate vehicles when the same listing appears in more than one supplied search URL.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
