# DBA.dk Scraper (`crawlerbros/dba-dk-scraper`) Actor

Scrape DBA.dk - Denmark's largest online marketplace for used and new items. Search by keyword, browse by category, search cars, or fetch full listing details by item ID/URL. Get prices, images, condition, location, seller type and more - no login required.

- **URL**: https://apify.com/crawlerbros/dba-dk-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## DBA.dk Scraper

Scrape [DBA.dk](https://www.dba.dk) — Denmark's largest online marketplace for new and used items. Search by keyword, browse any top-level category, search DBA's dedicated car marketplace, or pull full details for specific listings by ID/URL. Get prices, images, condition, location, seller type and more. No login, no API key, no cookies required.

### What this actor does

- **Five modes:** `search` (keyword), `browseCategory` (no keyword needed), `carSearch` (DBA's dedicated vehicle marketplace — cars, motorcycles, boats, caravans, motorhomes, ATVs & scooters), `itemDetail` (fetch specific listings), `sellerListings` (browse a dealer's entire shop)
- **Filters:** category, sub-category, product-category, region, city/town, map bounding box, price range, condition, listing type, private vs. dealer, brand, free shipping, published today, sort order
- **Vehicle marketplace** (`carSearch`): search cars (default), motorcycles, boats, caravans, motorhomes/camper vans, ATVs or scooters via `vehicleType` — each vertical returns its own specialized fields (e.g. boat motor power/speed/length, motorcycle engine size). No `searchQuery`/`carVariant` is required — omit both to browse every listing in a vertical, optionally narrowed by any other filter
- **Car-specific filters** (`carSearch`): make/model, model year range, max mileage, fuel type, transmission, body type, drivetrain, registration class, exterior colour, horsepower range, equipment (e.g. Apple CarPlay, tow bar, cruise control), warranty, documented service history, wheel-set count, allowed trailer/towing weight, dealer vs. private seller
- **Full-size images** with all photo URLs per listing
- **GPS coordinates** for map-based use cases
- **Buy Now / shipping indicators** — whether a listing supports instant checkout, seller-paid shipping, or DBA.dk's "Fiks færdig" shipping option
- **Item size** — clothing/shoe size, when the listing specifies one
- **Storage capacity & sport type** — device storage size (electronics) and sport/activity type (sport & outdoor), when the listing specifies one
- **Empty fields are omitted** — every record only contains data that was actually found

### Output per listing

- `itemId` — DBA.dk listing ID
- `title`, `description` (mode=`itemDetail` only)
- `priceAmount`, `priceCurrency` (DKK)
- `location` — city/region or full street address (detail mode)
- `postalCode` — Danish postal/zip code (mode=`itemDetail` only)
- `latitude`, `longitude` — approximate GPS coordinates (all modes except `sellerListings`)
- `category` — full category path (detail mode)
- `brand`
- `itemSize` — clothing or shoe size, when the listing specifies one (both `search`/`browseCategory` and `itemDetail` modes)
- `storageCapacity` — device storage size (e.g. `128 GB`), when the listing specifies one (electronics; `search`/`browseCategory` modes)
- `sportType` — sport/activity type (e.g. `Løb`, `Fitness`), when the listing specifies one (sport & outdoor items; `search`/`browseCategory` modes)
- `condition` — e.g. `Brand new`, `Used`, `Refurbished`, `Needs repair` (mode=`itemDetail` only; DBA.dk's search results don't expose a per-listing condition value even when the `condition` input filter is applied)
- `tradeType` — e.g. `Til salg` (for sale)
- `sellerName`, `sellerType` — `Private` or `Dealer`
- `shopSlug` — the dealer's shop slug (mode=`itemDetail` only, dealer listings), e.g. `bike4sport` — feed it straight into `mode=sellerListings` to pull every other listing from that same shop
- `buyNowAvailable` — `true` if the listing supports DBA.dk's instant "Buy now" checkout
- `shippingAvailable` — `true` if the seller offers DBA.dk's "Fiks færdig" shipping & payment handling
- `freeShipping` — `true` if the seller pays for shipping (matches the `shippingType` filter)
- `imageUrl`, `imageUrls[]` — full photo gallery (all photos, both `search`/`browseCategory` and `itemDetail` modes; single cover photo for `sellerListings`)
- `publishedAt` — ISO 8601 timestamp (`search`/`browseCategory` modes: exact; `sellerListings` mode: derived from the shop page's Danish "posted X ago" / date text, so it's accurate to the minute for just-posted listings, to the hour for listings posted earlier the same day, and to the day for older ones)
- `listingUrl`
- `recordType: "listing"`, `scrapedAt`

`mode=sellerListings` returns a lighter record per listing (`itemId`, `title`, `priceAmount`, `priceCurrency`, `location`, `imageUrl`, `sellerName`, `sellerType: "Dealer"`, `publishedAt`, `listingUrl`) since DBA.dk's shop pages don't expose the richer per-listing metadata that search/detail pages do — use `mode=itemDetail` with the returned `itemId`s for full details on any listing.

### Output per vehicle (mode=`carSearch`)

`mode=carSearch` scrapes DBA.dk's dedicated vehicle marketplace (`dba.dk/mobility`) — a distinct set of verticals from the general marketplace, with their own richer per-listing data. Use `vehicleType` to pick which vertical to search: `car` (default), `motorcycle`, `boat`, `caravan`, `motorhome`, `atv` or `scooter`. Records carry a `recordType` matching the vertical (`carListing`, `motorcycleListing`, `boatListing`, `caravanListing`, `motorhomeListing`, `atvListing`, `scooterListing`) and include:

- `itemId`, `title`, `listingUrl`, `location`, `latitude`/`longitude`, `publishedAt`, `priceAmount`/`priceCurrency`
- `make`, `carModel`, `series`, `modelSpecification` — manufacturer, model name, model series and trim (cars/motorcycles/caravans/motorhomes)
- `year` — first-registration year (or build year for boats)
- `mileage`, `mileageUnit` — odometer reading (cars/motorcycles/caravans/motorhomes)
- `fuel` — e.g. `Benzin` (petrol), `Diesel`, `El` (electric), `Hybrid benzin`
- `transmission` — `Manuelt` (manual) or `Automatisk` (automatic)
- `registrationClass` — e.g. `Personbil` (passenger car)
- `registrationNumber`, `chassisNumber` — Danish plate number and VIN, when disclosed on the listing
- `drivingRangeKm` — electric-vehicle range, when applicable
- `engineVolumeCc` — engine displacement in cc (motorcycles)
- `boatClass`, `motorType`, `motorFuel`, `motorPowerHp`, `maxSpeedKnots`, `lengthFt`, `widthCm` — boat-specific specs (`vehicleType=boat` only)
- `hasServiceHistory` — `true` when the seller has attached a documented service-history record (cars/motorcycles/caravans/motorhomes; omitted, not `false`, when none is attached)
- `warrantyMonths` — remaining manufacturer/dealer warranty in months, when disclosed (cars/motorcycles/caravans/motorhomes)
- `sellerType` — `Private` or `Dealer`
- `imageUrl`, `imageUrls[]` — full photo gallery
- `scrapedAt`

`mode=itemDetail` also works for any vehicle listing ID (car, motorcycle, boat, caravan or motorhome) — the actor automatically retries under DBA's vehicle item-URL pattern if the general marketplace URL 404s — though it returns a lighter record (no mileage/year/fuel/transmission, since those fields live only in the `carSearch` results) since vehicle detail pages don't embed the same rich data as general marketplace ones. Use `carSearch` for full vehicle specs.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `browseCategory` / `carSearch` / `itemDetail` / `sellerListings` |
| `searchQuery` | string | `cykel` | Free-text keyword (mode=`search`); free-text make/model search (mode=`carSearch`) |
| `category` | string | – | Top-level category (required for `browseCategory` unless `subCategory`/`productCategory` is set; optional filter for `search`) |
| `subCategory` | string | – | Narrower sub-category code, e.g. `1.90.82` (see below for how to find codes) |
| `productCategory` | string | – | Most specific product-category code, e.g. `2.90.82.4` |
| `sortBy` | string | `RELEVANCE` | `RELEVANCE` / `PUBLISHED_DESC` / `PUBLISHED_ASC` / `PRICE_DESC` / `PRICE_ASC` |
| `location` | string | – | Danish region filter |
| `subLocation` | string | – | Narrower city/town location code within a region, e.g. `1.200010.213700` (see below for how to find codes) |
| `condition` | string | – | Item condition filter |
| `tradeType` | string | – | For sale / giving away / wanted to buy |
| `dealerSegment` | string | – | Private seller vs. dealer |
| `priceMin` | int | – | Minimum price in DKK |
| `priceMax` | int | – | Maximum price in DKK |
| `shippingType` | string | – | Filter by delivery option: DBA shipping & payment handling ("Fiks færdig") or free shipping only |
| `boundingBox` | string | – | Restrict results to a rectangular map area: `minLon,minLat,maxLon,maxLat` (e.g. `12.4,55.6,12.7,55.8` covers central Copenhagen). Can be used alone or combined with any other filter |
| `publishedToday` | boolean | `false` | Only include listings published today |
| `brandQuery` | string | – | Only keep listings whose `brand` contains this text (case-insensitive) |
| `itemIds` | array | – | Listing IDs or URLs (mode=`itemDetail`) |
| `shopSlug` | string | – | Dealer shop slug or full shop URL, e.g. `bike4sport` (mode=`sellerListings`) |
| `vehicleType` | string | `car` | `car` / `motorcycle` / `boat` / `caravan` / `motorhome` / `atv` / `scooter` (mode=`carSearch`) — which mobility-marketplace vertical to search |
| `carVariant` | string | – | Car make/model code, e.g. `0.813` for Toyota (mode=`carSearch`; see below for how to find codes) |
| `yearMin` / `yearMax` | int | – | Model-year range (mode=`carSearch`) |
| `mileageMax` | int | – | Maximum odometer reading in km (mode=`carSearch`) |
| `fuelType` | string | – | Petrol / Diesel / Electric / Gas / Hybrid (mode=`carSearch`) |
| `transmissionType` | string | – | Manual / Automatic (mode=`carSearch`) |
| `bodyType` | string | – | Hatchback / Sedan / SUV / etc. (mode=`carSearch`) |
| `wheelDrive` | string | – | Front / rear / 4-wheel drive (mode=`carSearch`) |
| `carDealerSegment` | string | – | Private seller vs. dealer, for cars (mode=`carSearch`; separate from `dealerSegment` since DBA uses a different value mapping in this vertical) |
| `registrationClass` | string | – | Passenger car / van (mode=`carSearch`) |
| `exteriorColour` | string | – | Filter cars by exterior colour (mode=`carSearch`) |
| `engineEffectMin` / `engineEffectMax` | int | – | Horsepower range (mode=`carSearch`) |
| `carEquipment` | string | – | Filter cars by a single equipment feature, e.g. Apple CarPlay, tow bar, cruise control (mode=`carSearch`) |
| `warrantyInsurance` | string | – | Only include cars sold with a warranty (mode=`carSearch`) |
| `carCondition` | string | – | Only include cars with a documented service history (mode=`carSearch`) |
| `wheelSets` | string | – | Filter by number of included wheel sets, e.g. summer + winter tyres (mode=`carSearch`) |
| `trailerWeightMin` / `trailerWeightMax` | int | – | Allowed trailer/towing weight range in kg, 0–4000 (mode=`carSearch`) |
| `maxItems` | int | `50` | Hard cap on emitted records (1–1000) |

#### Finding sub-category / product-category codes

Browse any category on [dba.dk](https://www.dba.dk) and drill into a sub-category or product-category in the sidebar — the code appears in the page URL as `sub_category=1.xx.xxxx` or `product_category=2.xx.xxxx.xxxx`. Paste that code into `subCategory`/`productCategory` to scrape that exact listing group.

#### Finding city/town location codes

Select a region on [dba.dk](https://www.dba.dk) and drill into a specific city/town in the location filter sidebar — the code appears in the page URL as `location=1.xxxxxx.xxxxxx`. Paste that code into `subLocation` (optionally alongside the matching `location` region code) to scrape listings from that exact town.

#### Finding car make/model codes

Browse [dba.dk/mobility/search/car](https://www.dba.dk/mobility/search/car) and pick a make (and optionally a model) from the sidebar filter — the code appears in the page URL as `variant=0.xxx` (make only) or `variant=1.xxx.xxxx` (make + model). Paste that code into `carVariant` to scrape that exact make/model.

#### Example: search a map area

```json
{
  "mode": "search",
  "boundingBox": "12.4,55.6,12.7,55.8",
  "maxItems": 100
}
```

Get bounding-box coordinates from a tool like [bboxfinder.com](http://bboxfinder.com) (in `minLon,minLat,maxLon,maxLat` order) — useful for scraping every listing within a neighborhood, city, or custom map area regardless of DBA.dk's fixed region list.

#### Example: search with filters

```json
{
  "mode": "search",
  "searchQuery": "sofa",
  "location": "0.200001",
  "priceMin": 500,
  "priceMax": 5000,
  "condition": "3",
  "shippingType": "1",
  "sortBy": "PRICE_ASC",
  "maxItems": 100
}
```

#### Example: browse a category

```json
{
  "mode": "browseCategory",
  "category": "0.69",
  "dealerSegment": "1",
  "maxItems": 50
}
```

#### Example: fetch specific listings

```json
{
  "mode": "itemDetail",
  "itemIds": [
    "20578076",
    "https://www.dba.dk/recommerce/forsale/item/23807924"
  ]
}
```

#### Example: search cars

```json
{
  "mode": "carSearch",
  "searchQuery": "Golf",
  "fuelType": "2",
  "transmissionType": "2",
  "yearMin": 2015,
  "yearMax": 2022,
  "mileageMax": 150000,
  "priceMax": 250000,
  "maxItems": 100
}
```

#### Example: browse cars by filter only (no keyword)

```json
{
  "mode": "carSearch",
  "yearMin": 2018,
  "fuelType": "3",
  "transmissionType": "2",
  "maxItems": 100
}
```

#### Example: search boats

```json
{
  "mode": "carSearch",
  "vehicleType": "boat",
  "searchQuery": "motorbåd",
  "priceMax": 200000,
  "maxItems": 100
}
```

#### Example: browse a dealer's shop

```json
{
  "mode": "sellerListings",
  "shopSlug": "bike4sport",
  "maxItems": 200
}
```

### Categories

`0.90` Car/boat/motorcycle equipment · `0.77` Animals & equipment · `0.93` Electronics & appliances · `0.91` Business · `0.68` Parents & children · `0.67` Garden & renovation · `0.76` Art & antiques · `0.71` Fashion & beauty · `0.78` Furniture & interior · `0.69` Sport & outdoor · `0.86` Entertainment & hobby

### Use cases

- **Price monitoring & market research** — track asking prices for a product category (e.g. bicycles, furniture, electronics) across Denmark to spot pricing trends or undervalued listings
- **Car shopping & valuation** — filter DBA's vehicle marketplace by make, model year, mileage, fuel type and price to build a shortlist or benchmark a trade-in price
- **Dealer/reseller intelligence** — pull every active listing from a competitor's shop with `sellerListings` to monitor their inventory and pricing
- **Lead generation for local businesses** — find private sellers or dealers listing specific items (e.g. musical instruments, tools, appliances) in a given region
- **Real-estate-adjacent & relocation research** — use the map `boundingBox` filter to see what's for sale in a specific neighborhood or city
- **Marketplace aggregation** — feed structured DBA.dk listings (price, images, condition, location) into a price-comparison or classifieds-aggregator site

### FAQ

**Do I need a DBA.dk account or API key?**
No. This actor uses DBA.dk's publicly accessible pages — no login, cookies, or API key needed.

**What currency are prices in?**
Danish kroner (DKK).

**Can I filter by both keyword and category at the same time?**
Yes — in `search` mode, set both `searchQuery` and `category` to combine a keyword search with a category filter.

**Why do some listings lack a `sellerName`?**
Private sellers on DBA.dk don't have a public shop name; only dealer/professional listings expose one. The `sellerType` field always indicates whether a listing is `Private` or `Dealer`.

**How do I get the full description and exact address of a listing?**
Use `mode=itemDetail` with the listing's ID or URL — the search/browse modes only return summary fields.

**Can I filter to a specific brand?**
Yes — set `brandQuery` to a brand name (e.g. `Giant`, `Ikea`). Matching is a case-insensitive substring check against each listing's extracted `brand` field.

**Can I search a narrower sub-category than the 11 top-level categories?**
Yes — use `subCategory` and/or `productCategory` with a code copied from a dba.dk category URL. See "Finding sub-category / product-category codes" above.

**Are the GPS coordinates exact?**
`latitude`/`longitude` reflect the location DBA.dk associates with the listing (typically the seller's town/postal area), not necessarily an exact street address. `mode=itemDetail` also returns a `postalCode` alongside its coordinates.

**How do I scrape all listings from a specific dealer?**
Use `mode=sellerListings` with that dealer's `shopSlug` (found in their shop URL, e.g. `bike4sport` from `dba.dk/shop/bike4sport`, or copy that URL directly into `shopSlug`). You'll get every active listing in their shop. If you already have one of their listing IDs, run `mode=itemDetail` first — dealer records include a `shopSlug` field you can feed straight into `mode=sellerListings`.

**What do `buyNowAvailable`, `shippingAvailable` and `freeShipping` mean?**
`buyNowAvailable` is `true` when a listing supports DBA.dk's instant "Buy now" checkout instead of only messaging the seller. `shippingAvailable` is `true` when the seller has opted into DBA.dk's "Fiks færdig" shipping-and-payment handling. `freeShipping` is `true` when the seller covers the shipping cost — this is the same signal the `shippingType` input filter uses.

**Does this actor scrape cars too?**
Yes — use `mode=carSearch` to scrape DBA.dk's dedicated vehicle marketplace (`dba.dk/mobility`), which carries much richer per-listing data than a general item listing: make, model, model year, mileage, fuel type, transmission, registration number, chassis number (VIN) and more. It's a separate mode because DBA runs vehicles as a distinct set of verticals from the general marketplace, with their own filter set.

**Can it scrape motorcycles, boats, caravans, motorhomes, ATVs or scooters too?**
Yes — set `vehicleType` to `motorcycle`, `boat`, `caravan`, `motorhome`, `atv` or `scooter` alongside `mode=carSearch` to search that vertical instead of cars. Boats return boat-specific specs (`motorPowerHp`, `maxSpeedKnots`, `lengthFt`, `boatClass`, etc.) and motorcycles/ATVs/scooters include `engineVolumeCc`; the other filters (price, location, sort, etc.) work the same way across all vehicle types.

**Why does `carDealerSegment` exist separately from `dealerSegment`?**
DBA.dk's car marketplace uses a different internal value mapping for "private seller" vs. "dealer" than the general marketplace does, so the two filters can't share the same option values — use `dealerSegment` for `search`/`browseCategory` and `carDealerSegment` for `carSearch`.

**Can I filter cars by colour, horsepower, equipment or warranty?**
Yes — `mode=carSearch` supports `exteriorColour`, `engineEffectMin`/`engineEffectMax` (horsepower range), `carEquipment` (e.g. Apple CarPlay, tow bar, cruise control), `warrantyInsurance` (only cars sold with a warranty), `carCondition` (only cars with a documented service history), `wheelSets` (number of included wheel sets) and `trailerWeightMin`/`trailerWeightMax` (allowed towing weight in kg). These are DBA.dk's dedicated vehicle-marketplace filters and only apply to `carSearch`.

# Actor input Schema

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

What to fetch.

## `searchQuery` (type: `string`):

Free-text keyword search. For `mode=search`, e.g. `cykel`, `sofa`, `iphone`. For `mode=carSearch`, matches car make/model/free text, e.g. `Golf`, `Tesla`.

## `category` (type: `string`):

Top-level marketplace category (mode=browseCategory, required; optional filter for mode=search).

## `subCategory` (type: `string`):

Narrower DBA.dk sub-category code (e.g. `1.90.82` for car accessories & parts). Find codes by browsing a top-level category on dba.dk and copying the `sub_category` value from the URL. Optional filter for `search`/`browseCategory`; combine with `category` for best results.

## `productCategory` (type: `string`):

Most specific DBA.dk product-category code (e.g. `2.90.82.4` for roof racks & boxes). Find codes by browsing dba.dk and copying the `product_category` value from the URL. Optional filter for `search`/`browseCategory`.

## `sortBy` (type: `string`):

Result ordering. Applies to `search`, `browseCategory` and `carSearch`.

## `location` (type: `string`):

Limit results to a Danish region. Applies to `search`, `browseCategory` and `carSearch`.

## `subLocation` (type: `string`):

Narrower DBA.dk city/town location code (e.g. `1.200010.213700` for Rønne). Find codes by browsing dba.dk with a region selected and copying the `location` value from the URL for a specific city. Optional filter for `search`/`browseCategory`; combine with `location` for best results.

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

Item condition filter.

## `tradeType` (type: `string`):

Type of listing.

## `dealerSegment` (type: `string`):

Filter by private seller or professional dealer.

## `shippingType` (type: `string`):

Filter by delivery option.

## `boundingBox` (type: `string`):

Restrict results to a rectangular map area, as `minLon,minLat,maxLon,maxLat` (e.g. `12.4,55.6,12.7,55.8` covers central Copenhagen). Get coordinates from Google Maps or a bounding-box tool. Works for `search`/`browseCategory`/`carSearch`. Can be used alone (no `searchQuery`/`category` needed) or combined with any other filter.

## `publishedToday` (type: `boolean`):

Only include listings/cars that were published today. Applies to `search`, `browseCategory` and `carSearch`.

## `brandQuery` (type: `string`):

Only keep listings whose extracted `brand` contains this text (case-insensitive), e.g. `Giant`, `Ikea`, `Apple`.

## `priceMin` (type: `integer`):

Drop listings/cars priced below this amount (Danish kroner). Applies to all search modes.

## `priceMax` (type: `integer`):

Drop listings/cars priced above this amount (Danish kroner). Applies to all search modes.

## `itemIds` (type: `array`):

DBA.dk listing IDs (e.g. `20578076`) or full listing URLs.

## `shopSlug` (type: `string`):

A DBA.dk dealer shop slug (e.g. `bike4sport`) or full shop URL (e.g. `https://www.dba.dk/shop/bike4sport`). Find it by opening a dealer listing and clicking through to their shop page.

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

Which DBA.dk mobility-marketplace vertical to search. Each has its own filter nuances — `yearMin`/`yearMax`/`mileageMax`/`bodyType`/`wheelDrive`/`registrationClass` are most meaningful for cars/caravans/motorhomes; boats, motorcycles, ATVs and scooters instead expose fields like `motorPowerHp`, `boatClass` or `engineVolumeCc` in the output.

## `carVariant` (type: `string`):

DBA.dk car-marketplace make/model code (e.g. `0.813` for all Toyota, `1.8093.2476` for Abarth 500-series). Find codes by browsing `dba.dk/mobility/search/car` and copying the `variant` value from the URL after picking a make/model. Optional filter for `carSearch`; combine with `searchQuery` for best results.

## `yearMin` (type: `integer`):

Drop cars first registered before this year.

## `yearMax` (type: `integer`):

Drop cars first registered after this year.

## `mileageMax` (type: `integer`):

Drop cars with more kilometres on the odometer than this.

## `fuelType` (type: `string`):

Filter cars by fuel type.

## `transmissionType` (type: `string`):

Filter cars by gearbox type.

## `bodyType` (type: `string`):

Filter cars by body style.

## `wheelDrive` (type: `string`):

Filter cars by drivetrain.

## `carDealerSegment` (type: `string`):

Filter cars by private seller or professional dealer. Uses a different value mapping than the general `Seller type` filter, so it's a separate option.

## `registrationClass` (type: `string`):

Filter cars by vehicle registration class.

## `exteriorColour` (type: `string`):

Filter cars by exterior colour.

## `engineEffectMin` (type: `integer`):

Drop cars with less engine power than this, in hp.

## `engineEffectMax` (type: `integer`):

Drop cars with more engine power than this, in hp.

## `carEquipment` (type: `string`):

Only include cars with this equipment feature.

## `warrantyInsurance` (type: `string`):

Only include cars sold with a warranty.

## `carCondition` (type: `string`):

Only include cars with a documented service history.

## `wheelSets` (type: `string`):

Filter cars by how many wheel sets (e.g. summer + winter tyres) are included.

## `trailerWeightMin` (type: `integer`):

Drop cars with a lower permitted towing/trailer weight than this, in kg.

## `trailerWeightMax` (type: `integer`):

Drop cars with a higher permitted towing/trailer weight than this, in kg.

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "cykel",
  "category": "",
  "subCategory": "",
  "productCategory": "",
  "sortBy": "RELEVANCE",
  "location": "",
  "subLocation": "",
  "condition": "",
  "tradeType": "",
  "dealerSegment": "",
  "shippingType": "",
  "boundingBox": "",
  "publishedToday": false,
  "brandQuery": "",
  "itemIds": [],
  "shopSlug": "",
  "vehicleType": "car",
  "carVariant": "",
  "fuelType": "",
  "transmissionType": "",
  "bodyType": "",
  "wheelDrive": "",
  "carDealerSegment": "",
  "registrationClass": "",
  "exteriorColour": "",
  "carEquipment": "",
  "warrantyInsurance": "",
  "carCondition": "",
  "wheelSets": "",
  "maxItems": 50
}
```

# Actor output Schema

## `listings` (type: `string`):

Dataset containing all scraped DBA.dk listings.

# 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",
    "searchQuery": "cykel",
    "category": "",
    "subCategory": "",
    "productCategory": "",
    "sortBy": "RELEVANCE",
    "location": "",
    "subLocation": "",
    "condition": "",
    "tradeType": "",
    "dealerSegment": "",
    "shippingType": "",
    "boundingBox": "",
    "publishedToday": false,
    "brandQuery": "",
    "itemIds": [],
    "shopSlug": "",
    "vehicleType": "car",
    "carVariant": "",
    "fuelType": "",
    "transmissionType": "",
    "bodyType": "",
    "wheelDrive": "",
    "carDealerSegment": "",
    "registrationClass": "",
    "exteriorColour": "",
    "carEquipment": "",
    "warrantyInsurance": "",
    "carCondition": "",
    "wheelSets": "",
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/dba-dk-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",
    "searchQuery": "cykel",
    "category": "",
    "subCategory": "",
    "productCategory": "",
    "sortBy": "RELEVANCE",
    "location": "",
    "subLocation": "",
    "condition": "",
    "tradeType": "",
    "dealerSegment": "",
    "shippingType": "",
    "boundingBox": "",
    "publishedToday": False,
    "brandQuery": "",
    "itemIds": [],
    "shopSlug": "",
    "vehicleType": "car",
    "carVariant": "",
    "fuelType": "",
    "transmissionType": "",
    "bodyType": "",
    "wheelDrive": "",
    "carDealerSegment": "",
    "registrationClass": "",
    "exteriorColour": "",
    "carEquipment": "",
    "warrantyInsurance": "",
    "carCondition": "",
    "wheelSets": "",
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/dba-dk-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",
  "searchQuery": "cykel",
  "category": "",
  "subCategory": "",
  "productCategory": "",
  "sortBy": "RELEVANCE",
  "location": "",
  "subLocation": "",
  "condition": "",
  "tradeType": "",
  "dealerSegment": "",
  "shippingType": "",
  "boundingBox": "",
  "publishedToday": false,
  "brandQuery": "",
  "itemIds": [],
  "shopSlug": "",
  "vehicleType": "car",
  "carVariant": "",
  "fuelType": "",
  "transmissionType": "",
  "bodyType": "",
  "wheelDrive": "",
  "carDealerSegment": "",
  "registrationClass": "",
  "exteriorColour": "",
  "carEquipment": "",
  "warrantyInsurance": "",
  "carCondition": "",
  "wheelSets": "",
  "maxItems": 50
}' |
apify call crawlerbros/dba-dk-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawlerbros/dba-dk-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/gA6i4J2PYaVJ7IdHk/builds/1V5oB0M7nYhTfvcFF/openapi.json