# Luxauto Luxembourg Scraper: Cars, Leasing & Dealers (`recordsdata/luxauto-lu-scraper`) Actor

Scrape luxauto.lu, the Luxembourg vehicle marketplace: used and new cars, leasing and rental offers, motorcycles, vans, tyres, campers and dealers with prices, mileage, photos and equipment. No login, no proxy. Export JSON, CSV or Excel.

- **URL**: https://apify.com/recordsdata/luxauto-lu-scraper.md
- **Developed by:** [RecordsData](https://apify.com/recordsdata) (community)
- **Categories:** E-commerce, Lead generation
- **Security:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $22.00 / 1,000 vehicle listings

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

![RecordsData](https://api.apify.com/v2/key-value-stores/AAm3a1h3Z9nYfrvh9/records/banner?v=3)

## Luxauto Luxembourg Scraper: Cars, Leasing, Motorcycles and Dealers from luxauto.lu

> Luxauto Luxembourg Scraper is an Apify Actor that extracts vehicle listings from luxauto.lu, the Luxembourg marketplace for new and used cars, leasing offers, motorcycles, vans and tyres. Each row has price, make, model, year, mileage, fuel, power, photos and dealer data. Filter by make, price, year or seller, then export JSON, CSV or Excel.

Export the result as JSON, CSV, Excel, XML or HTML, or read it through the Apify API. The actor reads the same public pages and JSON that the luxauto.lu website shows to visitors, at a gentle pace of about four requests per second.

### What can you scrape from Luxauto?

On 2026-10-23 the site listed about 16,850 cars for sale, about 10,500 car leasing offers, 2 car rentals, about 1,300 motorcycles, about 850 tyre and rim ads, about 300 vans and 211 dealers in its directory. The actor reads all of them:

- **Vehicle listings** for 15 vehicle types: cars, motorcycles, vans, tyres and rims, quads, buggies, bicycles, caravans, campers, trailers, trucks, tractors and three accessory types. Each row has price, make, model, trim, year, mileage, fuel, gearbox, power, body type, colors, seats, town and the cover photo.
- **Leasing and rental offers**: the monthly payment of a leasing offer or the daily rate of a rental, with the lease type.
- **Ad details** (optional): the seller's description, the full photo gallery, the equipment list, the euro standard, CO2 emissions, the garage reference and the views.
- **Dealers**: the directory of 211 professional dealers with country, town, Google rating, vehicle count and, on request, the business phone, street, opening hours, languages and website.
- **Monitoring**: a repeat run returns only ads it has not delivered before.

### Why use this Luxauto scraper?

- **The whole catalogue is reachable**: no depth cap. A search for one make returned all 525 Porsche ads, and a broad car search pages through all 16,850 cars.
- **Real filters**: make, model, body type, price, year, mileage, engine size, power, fuel, gearbox, color, seats, condition, seller type, seller country, publication date and sort order. Most are applied by the site itself; power and condition are applied by the actor after reading.
- **Names are checked before the run**: an unknown make or model ends with one free error row that suggests close matches, instead of an empty dataset you pay for.
- **Clean, typed output**: numbers are numbers, enums are English, dates are ISO 8601 and absent values are left out instead of printed as null.
- **Privacy built in**: private sellers' names, phone numbers, street addresses and postal codes are never output, and phone numbers are removed from descriptions.
- **Fast and light**: plain HTTP, no browser, no proxy.

### How to scrape Luxauto listings in four steps

1. Choose **What to collect** on the actor page: ads, addresses or dealers.
2. Pick the offer type (sale, lease or rent) and the vehicle type, add makes such as `BMW` or `Porsche`, and set filters such as price, year or fuel.
3. Set **Maximum items** and click **Start**.
4. Download the dataset from the **Storage** tab as JSON, CSV, Excel or XML.

### Three ways to collect data

| Mode (`mode`) | Use it to | Record types |
|---|---|---|
| `search` | Find ads by offer type, vehicle type, make, model and the full filter set | `vehicle` |
| `urls` | Read known ads by number or address, replay a luxauto.lu search address, or read one dealer and its stock | `vehicle`, `dealer` |
| `dealers` | List the professional dealers, optionally with each dealer's current stock | `dealer`, `vehicle` |

The site spells Volkswagen as VW and Mercedes-Benz as Mercedes; the usual trade names are accepted as aliases, as are spellings such as Land Rover, Alfa Romeo or Rolls Royce. Switch on **Add ad details** to turn every `vehicle` row into a detail row with the description, the gallery and the equipment.

### What data do you get from Luxauto?

Every row has a `recordType`: `vehicle` or `dealer`. Fields that do not apply to a row are left out, never printed as null.

| Field | Description |
|---|---|
| `recordType`, `listingId`, `dealerId` | Record type, ad number and dealer number |
| `title`, `url`, `imageUrl`, `sourceSite`, `country` | Title, address of the ad, cover photo, `luxauto.lu` and the seller's country (`LU`, `FR`, `DE`, `BE`) |
| `listingType`, `vehicleType` | `sale`, `lease` or `rent`, and `car`, `motorcycle`, `van`, `tyres`, `quad`, `buggy`, `bicycle`, `caravan`, `camper`, `trailer`, `truck`, `tractor`, `accessory`, `car-accessory` or `motorcycle-accessory` |
| `make`, `model`, `trim`, `year`, `firstRegistration` | Vehicle identity; first registration as `YYYY-MM` |
| `bodyType`, `fuelType`, `transmission`, `driveType` | Specification as English labels, for example `SUV`, `Petrol`, `Automatic`, `Chain` |
| `engineSize`, `powerHp`, `seats` | Engine size in cc, power as the site shows it (CV) and number of seats |
| `color`, `interiorColor` | Exterior and interior color in English |
| `mileage`, `mileageUnit`, `condition` | Odometer in km, and `new`, `used` or `demonstrator` as the site tags it |
| `leaseType`, `monthlyPayment`, `pricePerDay`, `pricePeriod` | Leasing type, monthly payment, daily rental rate, and whether `price` is a `total`, `month` or `day` amount |
| `price`, `currency`, `priceOnRequest`, `vatRecoverable` | Asking price in EUR, `true` when the seller shows no price, and whether VAT can be recovered |
| `previousPrice`, `priceChange` | Struck-through old price and the difference when an ad was repriced |
| `euroStandard`, `energyEfficiencyClass`, `co2Emission` | Euro norm, A to G efficiency class and CO2 in g/km (detail rows) |
| `tyreWidth`, `tyreProfile`, `rimDiameter`, `tyreSeason`, `tyreIndex`, `rimMaterial` | Tyre and rim size, season, load and speed index, rim material |
| `city`, `postalCode`, `address` | Town; postal code for businesses; street only for dealers when contact details are switched on |
| `features`, `description`, `referenceCode` | Equipment list, the seller's text with contacts removed and the garage reference (detail rows) |
| `images`, `imageCount`, `publishedAt`, `viewCount` | Full-size gallery (detail rows), photo count, publication time and views |
| `isPrivateSeller`, `sellerName`, `sellerId`, `sellerUrl`, `isVipDealer` | Private or professional; the dealer identity is filled for businesses only |
| `sellerPhone` | Dealer business phone, only with **Include dealer contact details** |
| `vehicleCount`, `googleRating`, `googleReviewCount`, `googleMapsUrl`, `openingHours`, `languages`, `website` | Dealer rows: stock size, Google rating and review count, map link, opening hours, spoken languages and website |
| `raw`, `scrapedAt` | The site's own record (optional) and the time of the run |

Some columns are filled only when the seller typed them, for example the garage reference (about a third of ads), the euro standard and CO2 (about 30 percent) and the drive type (about 20 percent).

#### Sample output

A real detail row from a cloud run (equipment list, description and gallery shortened):

```json
{
  "imageUrl": "https://static.prd.luxauto.lu/pictures/occasions/x/1792758608_gxMrBtGbTxPOrTEu.jpg",
  "recordType": "vehicle",
  "title": "BMW M3 COMPETITION 510 CH",
  "listingId": "1948462",
  "url": "https://www.luxauto.lu/fr/voiture/bmw-m3-essence-2021-1948462",
  "sourceSite": "luxauto.lu",
  "country": "LU",
  "listingType": "sale",
  "vehicleType": "car",
  "make": "BMW",
  "model": "M3",
  "trim": "COMPETITION 510 CH",
  "year": 2021,
  "firstRegistration": "2021-05",
  "bodyType": "4/5 doors",
  "fuelType": "Petrol",
  "transmission": "Automatic",
  "powerHp": 510,
  "color": "Grey",
  "seats": 5,
  "mileage": 118124,
  "mileageUnit": "km",
  "condition": "used",
  "price": 59900,
  "currency": "EUR",
  "pricePeriod": "total",
  "vatRecoverable": true,
  "city": "Soleuvre",
  "postalCode": "4410",
  "features": ["ABS", "Airbags", "Air conditioning", "Alarm", "..."],
  "description": "Seller text, phone numbers replaced by a marker...",
  "images": [
    "https://static.prd.luxauto.lu/pictures/occasions/x/1792758608_gxMrBtGbTxPOrTEu.jpg",
    "..."
  ],
  "publishedAt": "2026-10-23T10:30:11.000Z",
  "isPrivateSeller": false,
  "sellerName": "GARAGE USED NEXT By Muzzolini",
  "sellerId": "429030",
  "sellerUrl": "https://www.luxauto.lu/fr/garage/garage-used-next-by-muzzolini-429030",
  "isVipDealer": true,
  "scrapedAt": "2026-10-23T18:57:55.765Z"
}
```

### How much does it cost to scrape Luxauto?

The actor uses pay per event pricing. Prices are USD per result on the Free tier.

| Event | Charged for | Price per result |
|---|---|---|
| `vehicle-record` | One ad row | $0.022 |
| `vehicle-detail-record` | One ad row with **Add ad details** | $0.0352 |
| `dealer-record` | One dealer row | $0.088 |

Examples: 1,000 ads cost $22.00, 1,000 ads with details cost $35.20 and 1,000 dealer rows cost $88.00. Skipped repeat ads, error rows and empty searches are free.

### Input parameters

| Input | Use it for |
|---|---|
| `mode` | `search`, `urls` or `dealers` |
| `makes`, `models` | Brand and model names |
| `fuelTypes`, `yearFrom`, `sort` | Common filters and order |
| `maxItems` | Maximum rows to return |

```json
{ "mode": "search", "makes": ["Audi"], "fuelTypes": ["diesel"], "yearFrom": 2018, "sort": "price-low", "maxItems": 20 }
```

### Monitor new Luxauto listings

Switch on **Only new ads (monitor)** and the actor remembers every ad it delivered, in a named key-value store of your own account. A scheduled run of the same search then returns only unseen ads. Sort by newest, add **Published within (days)** and give each saved search its own **Monitor name**. Skipped ads are never charged. In a test, a first run delivered 3 McLaren ads and the second run with the same input delivered 0.

### How does it compare with AutoScout24 scrapers?

No other Apify Store actor reads luxauto.lu: a Store search for "luxauto" returns no results on 2026-10-23. The Store has many AutoScout24 scrapers, for example [blackfalcondata/autoscout24-scraper](https://apify.com/blackfalcondata/autoscout24-scraper) (123 users in the last 30 days) and [scrapewise/autoscout24-scraper](https://apify.com/scrapewise/autoscout24-scraper). They read a different marketplace; the field counts below come from their published output views, read on 2026-10-23.

| | Luxauto Luxembourg Scraper | blackfalcondata/autoscout24-scraper | scrapewise/autoscout24-scraper |
|---|---|---|---|
| Source | luxauto.lu | AutoScout24 | AutoScout24 |
| Output fields | 72 flat, typed columns | 90 fields | 22 fields |
| Dealer data | Dealer rows for all 211 dealers (rating, stock size, hours, phone on request) plus seller fields on each ad | Seller fields on each listing | Dealer name on each listing |
| Leasing and rental | Monthly payment and daily rate in their own columns | Not in its published fields | `offerType` field |

### Is it legal to scrape Luxauto? Limits and responsible use

The actor reads public pages and the public JSON that the luxauto.lu website itself loads. It does not log in, solve captchas or bypass any protection. The robots.txt of luxauto.lu disallows only the sign-in, financing and account paths (`/fr/authentification`, `/fr/financement`, `/fr/mon-compte`), and the actor never opens them. It sends at most about four requests per second.

Private sellers' names, phone numbers, street addresses and postal codes are never output, and phone numbers and emails are removed from descriptions. Dealer phone and street are output only when you switch on **Include dealer contact details**. You are responsible for how you use the data, including data protection rules in your country.

Limits:

- The site has no power or condition filter, so those two filters are applied by the actor after reading; a narrow window can scan many pages (up to 3,000 ads per search).
- The site sorts by its own key. When you sort by price, a VAT-recoverable dealer ad can appear slightly out of order.
- Leasing and rental rows put the monthly or daily amount in `price`; read `pricePeriod`.
- Free Apify plans are limited to 10 results per run.

### Use with AI agents (MCP)

Connect the Apify MCP server to Claude, Cursor or another MCP client and this actor appears as a tool: `https://mcp.apify.com?tools=RecordsData/luxauto-lu-scraper`.

Example prompt: "List the 20 cheapest diesel Audi from 2018 or newer on Luxauto with mileage and dealer." The agent sends the input shown above and analyzes the rows.

### Run it from code

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('RecordsData/luxauto-lu-scraper').call({
    mode: 'search',
    makes: ['Porsche'],
    models: ['Cayenne'],
    yearFrom: 2019,
    scrapeDetails: true,
    maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, items[0].title, items[0].price);
```

You can also call the actor from the Python client, Make, Zapier or n8n, and schedule it from the Apify Console.

### Frequently Asked Questions

#### How do I scrape luxauto.lu listings?

Open the actor, keep the mode on `search`, choose sale, lease or rent and a vehicle type, add makes and filters, set **Maximum items** and start. The dataset has one row per ad. To refresh known ads, use the `urls` mode with ad numbers or luxauto.lu addresses.

#### Which vehicles does the Luxauto scraper cover?

Everything on luxauto.lu: cars, motorcycles, vans, tyres and rims, quads, buggies, bicycles, caravans, campers, trailers, trucks, tractors and accessories, for sale, for lease or for rent. The column `vehicleType` tells the types apart. Tyres and accessories have no make or model on the site, so those columns are left out for them.

#### Do I need a proxy, a login or an API key?

No. The actor makes plain HTTP requests to the public site and needs no proxy, browser or Luxauto account. You only need an Apify account to start runs, and the pay per event rates in the cost section above apply per result.

#### Is it legal to scrape Luxauto?

The actor reads publicly visible listings and does not log in. It keeps to the paths robots.txt allows and paces its requests to about four per second. Private sellers' personal data is not output. You remain responsible for how you use the data, including local data protection rules.

#### How many Luxauto listings can I get in one run?

The site sets no cap: about 16,850 cars for sale were reachable on 2026-10-23, and a single-make search returned every ad (525 of 525 for Porsche). Set `maxItems` to what you need. Free Apify plans are limited to 10 results per run.

#### Can I get leasing offers and monthly payments?

Yes. Set the offer type to lease. Each row has `monthlyPayment`, `leaseType` and `pricePeriod: "month"`, for example a Skoda Kodiaq lease with purchase option at 923 EUR a month. Rental offers carry `pricePerDay`; the site had only 2 car rentals on 2026-10-23.

#### Can I get only the ads published since my last run?

Yes. Switch on **Only new ads (monitor)**, sort by newest and keep the same search and **Monitor name**. A scheduled run of that search returns only the unseen ads, and the skipped ads are never charged, so a daily schedule stays cheap.

#### Why is there no seller name or phone on some rows?

Those rows belong to private sellers. Their name, phone, street and postal code are never output; only the town is, because the ad page itself shows it to every visitor. Dealer rows carry the business name, and the business phone and street appear when you switch on **Include dealer contact details**.

#### What does a price on request look like?

Some sellers leave the price empty or type 1 EUR as a placeholder. The row then has `priceOnRequest: true` and no `price`, so a fake price never reaches your analysis, your averages or your price comparisons between makes and models.

#### What happens when the search finds nothing or the input is wrong?

A search with no hits ends as succeeded with an empty dataset and charges nothing. A wrong input value, such as a minimum price above the maximum, an unknown make or a model without a make, ends as succeeded with one free error row that explains the problem and suggests close names.

### Support

Questions, a missing field or a feature request: contact.punkrecordsdata@gmail.com. Reviews on the actor page help other people find it.

This actor is an independent tool and is not affiliated with luxauto.lu.

Last updated: 2026-10-24

# Actor input Schema

## `mode` (type: `string`):

search = vehicle ads for the filters below. urls = luxauto.lu links or ad numbers you paste. dealers = the dealer directory. Example: search.

## `listingType` (type: `string`):

For sale = vehicles to buy. Leasing = monthly lease offers (the price is per month). Rental = vehicles to rent (the price is per day).

## `vehicleType` (type: `string`):

Which section of the site to read. One type per run.

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

Stops after this many rows. Free plans are capped at 10 rows per run. Example: 100.

## `makes` (type: `array`):

One per line, for example BMW, Mercedes-Benz, Volkswagen. Empty means every make.

## `models` (type: `array`):

Models of the makes above, for example X5 or Golf. Needs at least one make.

## `bodyTypes` (type: `array`):

Body or category names of the chosen vehicle type. Cars: 2/3 doors, 4/5 doors, Estate, Convertible, Coupe, Minivan, Pickup, SUV. Motorcycles: Scooter, Sport, Road / Touring, Custom / Chopper and others. An unknown name returns the list of valid ones.

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

Order of the results. Newest first is best for monitoring.

## `priceFrom` (type: `integer`):

Lowest price in euros, for example 10000. For leasing it is per month, for rentals per day. Empty means no limit.

## `priceTo` (type: `integer`):

Highest price in euros, for example 40000. For leasing it is per month, for rentals per day. Empty means no limit.

## `yearFrom` (type: `integer`):

Oldest model year, for example 2018. Empty means no limit.

## `yearTo` (type: `integer`):

Newest model year, for example 2024. Empty means no limit.

## `mileageFrom` (type: `integer`):

Lowest odometer reading in km, for example 0. Empty means no limit.

## `mileageTo` (type: `integer`):

Highest odometer reading in km, for example 100000. Empty means no limit.

## `publishedWithinDays` (type: `integer`):

Only ads published in the last N days, for example 7. Useful for daily monitoring together with Only new ads. 0 or empty means any time.

## `engineSizeFrom` (type: `integer`):

Only engines of at least this displacement in cubic centimetres, for example 1600. 0 or empty means no limit.

## `engineSizeTo` (type: `integer`):

Only engines of at most this displacement in cubic centimetres, for example 2500. 0 or empty means no limit.

## `powerFrom` (type: `integer`):

Only vehicles with at least this power in horsepower. The site has no power filter, so the actor reads ads and keeps the matching ones; ads without a power value are left out. 0 or empty means no limit.

## `powerTo` (type: `integer`):

Only vehicles with at most this power in horsepower. The site has no power filter, so the actor reads ads and keeps the matching ones; ads without a power value are left out. 0 or empty means no limit.

## `fuelTypes` (type: `array`):

Fuel or drive types to keep. Leave empty for all.

## `transmissions` (type: `array`):

Gearbox types to keep. Leave empty for all.

## `colors` (type: `array`):

Exterior colors to keep. Leave empty for all.

## `seats` (type: `integer`):

Only vehicles with this number of seats, for example 5 or 7. 0 or empty means any.

## `condition` (type: `string`):

New = new vehicles. Demonstrator = management or demonstration cars. Used = everything else. The site has no such filter, so the actor reads ads and keeps the matching ones.

## `sellerTypes` (type: `array`):

Private sellers, professional dealers, or both when empty.

## `sellerCountries` (type: `array`):

Country of the seller. luxauto.lu lists sellers from Luxembourg and from the neighbouring regions. Leave empty for all.

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

urls mode. luxauto.lu addresses in French (https://www.luxauto.lu/fr/...): a search (/fr/vente/voiture/bmw?...), a single ad (/fr/voiture/bmw-x5-...-1234567), a dealer (/fr/garage/name-12345) or the directory (/fr/annuaire-garages).

## `listingIds` (type: `array`):

urls mode. The number at the end of an ad address, for example 1921097.

## `dealerQuery` (type: `string`):

dealers mode. Keeps only dealers whose name contains this text, for example Losch. Empty means every dealer in the directory.

## `includeDealerVehicles` (type: `boolean`):

On: after each dealer row, also read that dealer's current ads (all vehicle types and offer types). Each ad is a separate row and is charged like any other ad.

## `scrapeDetails` (type: `boolean`):

On: one extra request per ad adds description, equipment list, euro standard and dealer address. Off (default): list data only, faster and cheaper.

## `includeContactDetails` (type: `boolean`):

Adds the business phone and street address of professional dealers (needs Add ad details for ads) and keeps phone numbers inside their descriptions. Private sellers never get contact data.

## `includeRaw` (type: `boolean`):

Adds a raw column with the site's own record (without photos, street, phone and contact person) next to the clean columns.

## `onlyNew` (type: `boolean`):

Skips every ad seen in an earlier run with the same monitor name and the same search, and does not charge for them. Schedule the actor to get only new ads.

## `stateKey` (type: `string`):

Name of the memory used by Only new ads. Use one name per saved search. Empty uses the filters themselves.

## `resetSeen` (type: `boolean`):

Clears the memory of the monitor name before this run.

## `maxConcurrency` (type: `integer`):

How many ad detail requests run at the same time (1 to 5). Request starts are spaced by the actor anyway.

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

Leave off: direct requests work. Add a proxy only if the site starts refusing your runs.

## Actor input object example

```json
{
  "mode": "search",
  "listingType": "sale",
  "vehicleType": "car",
  "maxItems": 10,
  "makes": [
    "BMW"
  ],
  "models": [],
  "bodyTypes": [],
  "sort": "relevance",
  "fuelTypes": [],
  "transmissions": [],
  "colors": [],
  "condition": "any",
  "sellerTypes": [],
  "sellerCountries": [],
  "startUrls": [],
  "listingIds": [],
  "dealerQuery": "",
  "includeDealerVehicles": false,
  "scrapeDetails": false,
  "includeContactDetails": false,
  "includeRaw": false,
  "onlyNew": false,
  "stateKey": "",
  "resetSeen": false,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Key fields per row

## `fullData` (type: `string`):

Complete dataset with all fields

# 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 = {
    "mode": "search",
    "maxItems": 10,
    "makes": [
        "BMW"
    ],
    "models": [],
    "bodyTypes": [],
    "startUrls": [],
    "listingIds": [],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("recordsdata/luxauto-lu-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 = {
    "mode": "search",
    "maxItems": 10,
    "makes": ["BMW"],
    "models": [],
    "bodyTypes": [],
    "startUrls": [],
    "listingIds": [],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("recordsdata/luxauto-lu-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 '{
  "mode": "search",
  "maxItems": 10,
  "makes": [
    "BMW"
  ],
  "models": [],
  "bodyTypes": [],
  "startUrls": [],
  "listingIds": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call recordsdata/luxauto-lu-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,recordsdata/luxauto-lu-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/SMniFSKiHKiMNC7NI/builds/EgrdA8E039jrUHkyq/openapi.json