# DBA Scraper - Danish Car Listings & Classifieds (`studio-amba/dba-scraper`) Actor

Scrape car listings from DBA.dk, Denmark's largest classifieds site. Extract prices, specs, mileage, fuel type, location. No login required.

- **URL**: https://apify.com/studio-amba/dba-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (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 usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

## DBA Scraper - Danish Car Listings & Classifieds

Scrape used car listings from [DBA.dk](https://www.dba.dk), Denmark's largest and most popular classifieds marketplace. Extract structured data including prices, vehicle specifications, mileage, fuel type, seller info, and more. No login or cookies required.

DBA.dk (Den Bla Avis) is Denmark's #1 marketplace with over 20,000 active vehicle listings at any time, owned by Adevinta (formerly eBay Classifieds Group). This scraper targets the cars/vehicles (biler) section.

### Why use this scraper?

- **No login or cookies** -- works without any authentication
- **Structured data** -- raw listing data parsed into clean fields (price, year, mileage, fuel type, transmission)
- **Flexible search** -- filter by keyword, year range, price range, fuel type
- **Handles anti-bot** -- built-in fingerprint evasion, residential proxy support, cookie consent dismissal
- **Danish market coverage** -- access the largest used car marketplace in Denmark
- **Pagination** -- automatically follows search results across multiple pages
- **Private and dealer listings** -- captures both Privat and Forhandler (dealer) sellers
- **Export-ready** -- download results as JSON, CSV, Excel, or connect via API

### How to scrape DBA data

1. **Go to this actor's page** on Apify Store and click "Try for free"
2. **Enter your search query** -- for example "volkswagen", "BMW 3", or "Tesla Model 3"
3. **Set optional filters** -- narrow results by year range, price range, or fuel type
4. **Set max results** -- default is 100, adjust based on your needs
5. **Configure proxy** -- Danish residential proxies are pre-configured for best results
6. **Run the scraper** and download your data in JSON, CSV, or Excel format

### Input parameters

| Parameter | Type | Description |
|-----------|------|-------------|
| `searchQuery` | string | Search term (e.g. "volkswagen", "audi a4"). Default: "volkswagen" |
| `make` | string | Car brand for output tagging (e.g. "VW", "BMW") |
| `model` | string | Car model for output tagging (e.g. "Golf", "Passat") |
| `yearFrom` | integer | Minimum model year (e.g. 2018) |
| `yearTo` | integer | Maximum model year (e.g. 2024) |
| `priceFrom` | integer | Minimum price in DKK |
| `priceTo` | integer | Maximum price in DKK |
| `fuelType` | string | Benzin, Diesel, El, Hybrid, Plug-in Hybrid, or Gas |
| `sort` | string | Sort order: relevance, price, year, mileage, or date |
| `maxResults` | integer | Maximum listings to scrape (default: 100) |
| `proxyConfiguration` | object | Proxy settings (Danish residential pre-configured) |

### Output example

Each listing is returned as a JSON object with the following structure:

```json
{
    "listingTitle": "VW Passat 2.0 TDi 150 Highline Variant DSG",
    "make": "VW",
    "model": "Passat 2.0 TDi",
    "year": 2019,
    "price": 249000,
    "currency": "DKK",
    "mileage": 142000,
    "fuelType": "Diesel",
    "transmission": "Automatisk",
    "engineSize": "1968 cc",
    "location": "Odense",
    "sellerType": "Forhandler",
    "imageUrl": "https://images.dbastatic.dk/dynamic/480w/item/12345/abc123",
    "url": "https://www.dba.dk/mobility/item/12345678",
    "scrapedAt": "2026-06-09T12:00:00.000Z"
}
````

### Data fields

| Field | Type | Description |
|-------|------|-------------|
| `listingTitle` | string | Full listing title from DBA |
| `make` | string | Car manufacturer (VW, BMW, Audi, etc.) |
| `model` | string | Car model and variant |
| `year` | integer | Model year (e.g. 2019) |
| `price` | number | Price in DKK (Danish kroner). Uses period as thousands separator on site, parsed to integer |
| `currency` | string | Always "DKK" |
| `mileage` | number | Odometer reading in kilometers |
| `fuelType` | string | Benzin (petrol), Diesel, El (electric), Hybrid |
| `transmission` | string | Automatisk (automatic) or Manuelt (manual) |
| `engineSize` | string | Engine displacement in cc (e.g. "1968 cc") |
| `location` | string | City or region in Denmark |
| `sellerType` | string | Privat (private seller) or Forhandler (dealer) |
| `imageUrl` | string | URL of the main listing photo |
| `url` | string | Direct link to the listing on DBA.dk |
| `scrapedAt` | string | ISO 8601 timestamp when the data was scraped |

### Cost estimate

Running this scraper on the Apify platform typically costs:

- **50 listings**: ~$0.10 (under 1 minute)
- **200 listings**: ~$0.30 (2-3 minutes)
- **1,000 listings**: ~$1.50 (10-15 minutes)

Costs depend on proxy usage and the number of pages navigated. Residential proxies (recommended) cost more than datacenter proxies but provide better reliability.

### Tips for best results

- **Use specific search terms** -- "volkswagen golf" returns more targeted results than just "volkswagen"
- **Combine filters** -- use yearFrom/yearTo with priceFrom/priceTo to narrow down results
- **Danish residential proxies** -- pre-configured and recommended. DBA.dk may block datacenter IPs
- **Start with fewer results** -- test with maxResults=10 to verify your filters before running a large scrape
- **Sort by price** -- use PRICE\_ASC to find the cheapest deals first
- **Fuel type filter** -- use "El" for electric vehicles, which are very popular in Denmark

### FAQ

**Can I scrape all vehicles, not just cars?**
This scraper focuses on the cars (biler) section with `registration_class=1`. For vans, motorcycles, or other vehicle types, you would need to modify the registration\_class parameter.

**What proxy should I use?**
Danish residential proxies are pre-configured and provide the best success rate. Datacenter proxies may work but can be blocked more frequently.

**How often is DBA updated?**
New listings appear on DBA.dk constantly throughout the day. For monitoring purposes, running the scraper daily or weekly captures most market changes.

**Can I scrape individual listing pages for more details?**
This scraper extracts data from search result pages. The fields available are those shown on listing cards (title, price, year, mileage, fuel, transmission, location, seller type). Full listing pages may contain additional details like equipment lists and seller descriptions.

**Is the data in Danish?**
Yes. Field values like fuel type (Benzin, Diesel, El), transmission (Automatisk, Manuelt), and seller type (Privat, Forhandler) are in Danish, matching the site's language.

### About DBA.dk

DBA (Den Bla Avis / "The Blue Paper") is Denmark's largest online classifieds marketplace, originally founded as a print classifieds newspaper in 1981. It is now owned by Adevinta, the global classifieds group. DBA hosts listings across all categories -- vehicles, electronics, furniture, real estate, and more -- with the vehicles section being one of its most active categories. The site typically has 15,000-20,000+ active car listings at any time, making it the primary destination for buying and selling used cars in Denmark.

# Actor input Schema

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

Search term for car listings (e.g. 'volkswagen', 'BMW 3', 'Tesla Model 3'). Leave empty to use default search.

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

Car manufacturer to filter by (e.g. 'VW', 'BMW', 'Audi', 'Toyota'). Used to tag output data. Use searchQuery for the actual site search.

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

Specific car model (e.g. 'Golf', 'Passat', '3 Series'). Used to tag output data. Use searchQuery for the actual site search.

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

Minimum model year filter (e.g. 2018).

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

Maximum model year filter (e.g. 2024).

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

Minimum price in Danish kroner.

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

Maximum price in Danish kroner.

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

Filter by fuel type.

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

How to sort the results.

## `maxResults` (type: `integer`):

Maximum number of car listings to scrape.

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

Proxy settings. Danish residential proxies recommended for best results.

## Actor input object example

```json
{
  "searchQuery": "volkswagen",
  "sort": "RELEVANCE",
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "DK"
  }
}
```

# 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 = {
    "searchQuery": "volkswagen",
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "DK"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/dba-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 = {
    "searchQuery": "volkswagen",
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "DK",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/dba-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 '{
  "searchQuery": "volkswagen",
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "DK"
  }
}' |
apify call studio-amba/dba-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "DBA Scraper - Danish Car Listings & Classifieds",
        "description": "Scrape car listings from DBA.dk, Denmark's largest classifieds site. Extract prices, specs, mileage, fuel type, location. No login required.",
        "version": "0.1",
        "x-build-id": "NXjRcuedo0z5qLhaE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~dba-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-dba-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/studio-amba~dba-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-dba-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/studio-amba~dba-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-dba-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search term for car listings (e.g. 'volkswagen', 'BMW 3', 'Tesla Model 3'). Leave empty to use default search."
                    },
                    "make": {
                        "title": "Make (Brand)",
                        "type": "string",
                        "description": "Car manufacturer to filter by (e.g. 'VW', 'BMW', 'Audi', 'Toyota'). Used to tag output data. Use searchQuery for the actual site search."
                    },
                    "model": {
                        "title": "Model",
                        "type": "string",
                        "description": "Specific car model (e.g. 'Golf', 'Passat', '3 Series'). Used to tag output data. Use searchQuery for the actual site search."
                    },
                    "yearFrom": {
                        "title": "Year From",
                        "minimum": 1950,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Minimum model year filter (e.g. 2018)."
                    },
                    "yearTo": {
                        "title": "Year To",
                        "minimum": 1950,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Maximum model year filter (e.g. 2024)."
                    },
                    "priceFrom": {
                        "title": "Minimum Price (DKK)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price in Danish kroner."
                    },
                    "priceTo": {
                        "title": "Maximum Price (DKK)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price in Danish kroner."
                    },
                    "fuelType": {
                        "title": "Fuel Type",
                        "enum": [
                            "Benzin",
                            "Diesel",
                            "El",
                            "Hybrid",
                            "Plug-in Hybrid",
                            "Gas"
                        ],
                        "type": "string",
                        "description": "Filter by fuel type."
                    },
                    "sort": {
                        "title": "Sort By",
                        "enum": [
                            "RELEVANCE",
                            "PRICE_ASC",
                            "PRICE_DESC",
                            "YEAR_DESC",
                            "YEAR_ASC",
                            "MILEAGE_ASC",
                            "MILEAGE_DESC",
                            "PUBLISHED_DESC"
                        ],
                        "type": "string",
                        "description": "How to sort the results.",
                        "default": "RELEVANCE"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of car listings to scrape.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Danish residential proxies recommended for best results."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
