# DBA.dk Scraper — Denmark Classifieds & Prices (`logiover/dba-dk-scraper`) Actor

Scrape dba.dk, Denmark's #1 classifieds marketplace: title, price (DKK), location, image, seller type (private/dealer) and posted date — plus car make, model, year, mileage and fuel for vehicles. Paste any dba.dk search or category URL. No login, no API key.

- **URL**: https://apify.com/logiover/dba-dk-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** E-commerce, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

<div align="center">

<img src="https://cdn-icons-png.flaticon.com/128/3081/3081559.png" width="92" alt="DBA.dk Scraper"/>

## 🇩🇰 DBA.dk Scraper — Denmark Classifieds & Used-Car Data

#### The **dba scraper** that turns any **dba.dk** search into a clean dataset — title, price in DKK, location, seller type, posted date **and full car specs (make, model, year, mileage, fuel)**

<p>
<img src="https://img.shields.io/badge/✓_NO_LOGIN-no_API_key-2ea44f?style=for-the-badge&labelColor=0b3d2e"/>
<img src="https://img.shields.io/badge/🇩🇰_DBA.DK-Denmark's_#1_marketplace-c8102e?style=for-the-badge&labelColor=6e0a1a"/>
<img src="https://img.shields.io/badge/🚗_CARS_+-all_categories-1f6feb?style=for-the-badge&labelColor=0b2e6b"/>
</p>
<p>
<img src="https://img.shields.io/badge/Cars-make·model·year·km-008060?style=flat-square"/>
<img src="https://img.shields.io/badge/Price-DKK-e91e63?style=flat-square"/>
<img src="https://img.shields.io/badge/Seller-private_or_dealer-9c27b0?style=flat-square"/>
<img src="https://img.shields.io/badge/Export-JSON·CSV·Excel·API-f59e0b?style=flat-square"/>
</p>

<br/>

**The fastest way to turn any <a href="https://www.dba.dk">dba.dk</a> search into a clean dataset.** This **dba.dk scraper** collects **Denmark classifieds data** and **Denmark used-cars data** from Den Blå Avis — Denmark's largest second-hand marketplace — with **no login, no cookies and no API key**. 🏷️ Price in DKK · 📍 city/location + coordinates · 🧑 seller type (private / dealer) · 🕒 posted date · 🖼️ images · 🚗 for **dba biler** (cars): make, model, year, mileage, fuel, transmission & number plate.

</div>

---

### 🚀 Why scrape DBA.dk?

**DBA.dk (Den Blå Avis)** is **Denmark's largest classifieds marketplace** (part of Schibsted) — used cars, electronics, home & furniture, leisure, and almost everything else Danes buy and sell second-hand. This **danish marketplace scraper** reads the site's own structured listing data (the JSON payload behind every search page), so you get clean, typed fields with no login and no API key, and it paginates through the result set automatically.

It's two tools in one:

> 🚗 a **Denmark used-cars dataset** — price tracking, depreciation models, dealer-vs-private analysis, market comps & ML — and
> 📊 a **Danish second-hand marketplace dataset** — price intelligence, demand research, reselling & arbitrage, dashboards.

---

### ❓ What does the DBA.dk scraper do?

You paste one or more **dba.dk** search or category URLs, and the actor returns one clean, structured row per listing — ready to download as **CSV, Excel or JSON**, or pull from the **Apify API**.

It covers **two of dba.dk's platforms with one parser**:

| Platform | Example URL | What you get |
|---|---|---|
| 🚗 **Vehicles** (cars, MC, boats, vans) | `https://www.dba.dk/mobility/search/car?registration_class=1` | Rich car fields: **make, model, year, mileage, fuel, transmission, number plate**, plus all common fields |
| 🏷️ **General classifieds** (everything else) | `https://www.dba.dk/recommerce/forsale/search?q=iphone` or a category `…?category=0.93` | Title, price, location, brand, seller type, trade type, images |

**How to get a URL:** go to dba.dk, set your filters / type your search / open a category, then copy the URL from the address bar and paste it into the **Search / category URLs** input. The cars search (`/biler/biler/`) redirects to the mobility URL; a keyword search or homepage category link redirects to the `recommerce/forsale/search` URL — both are supported as-is.

---

### ✨ Features

- 🔑 **No login, no API key, no cookies** — works as an unofficial **dba.dk API** alternative, reading the site's own embedded listing JSON.
- 🚗 **Full car specs** — **scrape dba.dk car listings** with make, model, year, mileage (km), fuel, transmission and Danish number plate.
- 🏷️ **Cars + all general goods** — paste any vehicles or general `recommerce` search/category URL (electronics, home, leisure, fashion…).
- 🧑 **Seller type** — every row tagged **private** or **dealer**, with an optional `sellerType` filter for dealer-only or private-only runs.
- 💸 **Clean numeric prices** in DKK (plus the raw `24.500 kr.` text).
- 📍 **Location + coordinates** — city name and approximate latitude / longitude.
- 🕒 **Posted date** as ISO 8601, so you can sort by freshness.
- 🔁 **Auto-pagination** with de-duplication by listing ID and `maxResults` caps.
- 📤 **Denmark classifieds data export to CSV, Excel, JSON or API** in one click.
- 🌐 **Datacenter proxy is enough** (dba.dk is not Cloudflare-challenged) — cheap to run.

---

### 📦 What data you get

One row per listing. Fields below are **verified** output.

#### Common fields (all listings)

| Field | Description | Example |
|---|---|---|
| `listingId` | Unique dba.dk listing ID | `"22052485"` |
| `url` | Full listing URL | `"https://www.dba.dk/mobility/item/22052485"` |
| `title` | Listing headline | `"Volvo S40"` |
| `price` | Asking price as a number (DKK) | `24500` |
| `priceRaw` | Price exactly as shown on dba.dk | `"24.500 kr."` |
| `currency` | Currency code | `"DKK"` |
| `location` | City / town | `"Kruså"` |
| `latitude` / `longitude` | Approximate GPS coordinates | `54.86647` / `9.43728` |
| `category` | `vehicles` or `general` | `"vehicles"` |
| `subCategory` | dba.dk sub-category label | `"Personbil"` |
| `sellerType` | `private` or `dealer` | `"private"` |
| `tradeType` | Trade type label (e.g. `Til salg`) | `"Til salg"` |
| `postedDate` | Publication time (ISO 8601) | `"2026-06-07T17:04:58.000Z"` |
| `image` | Cover photo URL | `"https://images.dbastatic.dk/…"` |
| `imagesCount` | Number of photos on the listing | `10` |
| `brand` | Product brand (general goods) | `"Apple"` |

#### 🚗 Vehicle-only fields (`category = vehicles`)

| Field | Description | Example |
|---|---|---|
| `make` | Car make | `"Volvo"` |
| `model` | Car model | `"S40"` |
| `year` | Model year | `2006` |
| `mileage` | Odometer in km | `252000` |
| `fuel` | Fuel type | `"Benzin"` |
| `transmission` | Gearbox | `"Manuelt"` |
| `regNo` | Danish number plate (if listed) | `"EF86096"` |

---

### 🛠️ How to use

#### Input fields

| Field | Type | Default | Description |
|---|---|---|---|
| `searchUrls` | array | used-cars search | dba.dk search/category URLs copied from the site. Empty = scrape used cars. |
| `maxResults` | integer | `200` | Stop after this many listings across all URLs. `0` = no limit. |
| `maxResultsPerSearch` | integer | `0` | Cap per individual URL. `0` = no per-search cap. |
| `sellerType` | select | `any` | Keep only `private` sellers, only `dealer`s, or `any`. |
| `useProxy` | boolean | `true` | Route through Apify Proxy. |
| `proxyConfiguration` | object | Datacenter | Proxy settings. Datacenter works; switch to Residential only if blocked. |

#### Example 1 — Denmark used cars by filter

Set your filters on dba.dk's car search, copy the URL, paste it in:

```json
{
  "searchUrls": ["https://www.dba.dk/mobility/search/car?registration_class=1"],
  "maxResults": 1000
}
````

#### Example 2 — Electronics search (e.g. iPhone)

```json
{
  "searchUrls": ["https://www.dba.dk/recommerce/forsale/search?q=iphone"],
  "maxResults": 500
}
```

#### Example 3 — Dealer-only car listings

```json
{
  "searchUrls": ["https://www.dba.dk/mobility/search/car?registration_class=1"],
  "sellerType": "dealer",
  "maxResults": 500
}
```

You can also mix vehicles and general categories in a single run by adding multiple URLs to `searchUrls`.

***

### 📤 Example output

A used car:

```json
{
  "listingId": "22052485",
  "url": "https://www.dba.dk/mobility/item/22052485",
  "title": "Volvo S40",
  "price": 24500,
  "priceRaw": "24.500 kr.",
  "currency": "DKK",
  "location": "Kruså",
  "latitude": 54.86647,
  "longitude": 9.43728,
  "category": "vehicles",
  "subCategory": "Personbil",
  "sellerType": "private",
  "tradeType": null,
  "postedDate": "2026-06-07T17:04:58.000Z",
  "image": "https://images.dbastatic.dk/dynamic/default/item/22052485/6261ef04-…",
  "imagesCount": 1,
  "make": "Volvo",
  "model": "S40",
  "year": 2006,
  "mileage": 252000,
  "fuel": "Benzin",
  "transmission": "Manuelt",
  "regNo": "EF86096"
}
```

A general classifieds item:

```json
{
  "listingId": "22052953",
  "url": "https://www.dba.dk/recommerce/forsale/item/22052953",
  "title": "Apple MacBook bærbar computer 13\" grå",
  "price": 2000,
  "priceRaw": "2.000 kr.",
  "currency": "DKK",
  "location": "Vejle",
  "category": "general",
  "subCategory": "Elektronik og hvidevarer",
  "sellerType": "private",
  "tradeType": "Til salg",
  "brand": "Apple",
  "image": "https://images.dbastatic.dk/dynamic/default/item/22052953/f17798bc-…",
  "imagesCount": 10
}
```

Export to **JSON, CSV, Excel, or the API** from the Storage tab.

***

### 🎯 Use cases

| | Use case | How |
|---|---|---|
| 🚗 | **Denmark used-car price analysis** | Track DKK prices, mileage and year by make/model to build depreciation curves and valuation models from real **Denmark used cars data**. |
| 📊 | **Marketplace & competitor monitoring** | Watch prices, inventory and new-listing velocity across categories on Denmark's biggest classifieds site. |
| 🧑‍💼 | **Dealer lead generation** | Filter to `dealer` listings to build a list of Danish car dealers and active sellers by region or category. |
| 🔁 | **Resale & arbitrage research** | Spot underpriced electronics, furniture and gear for flipping between dba.dk and other platforms. |
| 🤖 | **AI / ML datasets** | Feed Danish-language product listings, prices and attributes into pricing models and training sets. |

***

### 🤖 Automate it

Put it on an **Apify Schedule** → a fresh dba.dk listings feed every morning, straight to the **Apify API, a webhook, Google Sheet, S3** or your warehouse. Track new listings and price drops across the Danish market on autopilot.

***

### ❓ FAQ

#### Is there a DBA.dk API?

DBA.dk has no public developer API. This actor works as an **unofficial dba api alternative** — it reads dba.dk's own structured search payload and returns clean, machine-readable rows with no API key, no login and no cookies.

#### Can I scrape dba.dk car listings?

Yes. Paste a `mobility/search/...` car URL (or MC / boat / van) and you get full **dba biler** specs — make, model, year, mileage, fuel, transmission and Danish number plate — alongside price, location and seller type.

#### How do I export DBA data to Excel or CSV?

Run the actor on any dba.dk search URL, then download the dataset from the Storage tab as **CSV, Excel or JSON** — or pull it from the Apify API. Every field above is included in one structured table, so **Denmark classifieds data export to CSV/Excel** is a single click.

#### How many listings can I scrape from dba.dk?

dba.dk hard-caps any single search or category at **50 pages (~2,600 listings)** — that's a site limit, not the scraper's. To pull more, split your query into narrower searches (by category, brand, price band or region) and paste each URL into `searchUrls`.

#### Does it scrape every car detail (VIN, equipment list, full description)?

It returns everything in the search payload — make, model, year, mileage, fuel, transmission, number plate, price, location, image and more. Listing **detail pages are not crawled separately**, so free-text descriptions, full equipment lists and VINs are out of scope — this keeps runs fast and cheap.

#### What proxy should I use?

**Datacenter** (the default) works reliably — dba.dk is not behind a Cloudflare challenge. Switch to **Residential** only if you ever see blocks.

#### Is scraping dba.dk legal?

This **danish second-hand marketplace** scraper collects publicly visible listing data — the same information any visitor sees without logging in. Use it responsibly, respect dba.dk's terms, and don't store personal data beyond what you actually need. You are responsible for compliance with applicable laws in your jurisdiction.

***

### 📝 Changelog

#### 2026-06-07

- Docs: comprehensive SEO rewrite — coverage for the dba.dk API alternative, scraping dba.dk car listings (dba biler), exporting Denmark classifieds data to CSV/Excel, and honest scope/coverage notes.

***

<div align="center">

**dba scraper** · **dba.dk scraper** · **denmark classifieds data** · **dba biler scraper** · **danish marketplace scraper** · **denmark used cars data** · **dba api** · Den Blå Avis · DKK price dataset

<sub>No login · No API key · JSON · CSV · Excel · API</sub>

</div>

# Actor input Schema

## `searchUrls` (type: `array`):

dba.dk search or category URLs copied straight from the site. Cars: https://www.dba.dk/mobility/search/car?registration\_class=1 — General items: https://www.dba.dk/recommerce/forsale/search?q=iphone or a category like https://www.dba.dk/recommerce/forsale/search?category=0.93 (Electronics). Set your filters on dba.dk, then paste the result URL(s) here. Leave empty to scrape used cars by default.

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

Stop after this many listings across all URLs. 0 = no limit (dba.dk caps a single search at 50 pages / ~2600 listings).

## `maxResultsPerSearch` (type: `integer`):

Cap listings per individual search/category URL. 0 = no per-search cap.

## `sellerType` (type: `string`):

Optionally keep only private sellers or only dealers. 'any' keeps everything the URL returns.

## `useProxy` (type: `boolean`):

Route requests through Apify Proxy. Datacenter proxy works reliably on dba.dk and is the default.

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

Apify Proxy settings. Datacenter is enough for dba.dk; switch to Residential only if you hit blocks.

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

How many search/category URLs to process in parallel.

## Actor input object example

```json
{
  "searchUrls": [
    "https://www.dba.dk/mobility/search/car?registration_class=1"
  ],
  "maxResults": 200,
  "maxResultsPerSearch": 0,
  "sellerType": "any",
  "useProxy": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxConcurrency": 3
}
```

# Actor output Schema

## `listingId` (type: `string`):

dba.dk ad ID

## `url` (type: `string`):

Canonical listing URL

## `title` (type: `string`):

Listing title / heading

## `price` (type: `string`):

Price as a number (DKK)

## `priceRaw` (type: `string`):

Raw price text, e.g. 24.500 kr.

## `currency` (type: `string`):

Currency code (DKK)

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

City / town of the seller

## `latitude` (type: `string`):

Approximate latitude

## `longitude` (type: `string`):

Approximate longitude

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

Top-level platform: vehicles or general (recommerce)

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

Search/category title from dba.dk (e.g. Personbil, Elektronik og hvidevarer)

## `sellerType` (type: `string`):

private or dealer

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

e.g. Til salg (for sale), Gives væk (free)

## `postedDate` (type: `string`):

When the ad was published (ISO 8601)

## `image` (type: `string`):

Main image URL

## `imagesCount` (type: `string`):

Number of images on the listing

## `brand` (type: `string`):

Brand / make of the item (general items)

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

Car make (vehicles)

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

Car model (vehicles)

## `year` (type: `string`):

Registration year (vehicles)

## `mileage` (type: `string`):

Mileage in km (vehicles)

## `fuel` (type: `string`):

Fuel type (vehicles)

## `transmission` (type: `string`):

Gearbox / transmission (vehicles)

## `regNo` (type: `string`):

Danish number plate (vehicles)

## `sourceUrl` (type: `string`):

The search/category URL this row came from

## `scrapedAt` (type: `string`):

Scrape timestamp (ISO 8601)

# 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 = {
    "searchUrls": [
        "https://www.dba.dk/mobility/search/car?registration_class=1"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/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 = { "searchUrls": ["https://www.dba.dk/mobility/search/car?registration_class=1"] }

# Run the Actor and wait for it to finish
run = client.actor("logiover/dba-dk-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 '{
  "searchUrls": [
    "https://www.dba.dk/mobility/search/car?registration_class=1"
  ]
}' |
apify call logiover/dba-dk-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "DBA.dk Scraper — Denmark Classifieds & Prices",
        "description": "Scrape dba.dk, Denmark's #1 classifieds marketplace: title, price (DKK), location, image, seller type (private/dealer) and posted date — plus car make, model, year, mileage and fuel for vehicles. Paste any dba.dk search or category URL. No login, no API key.",
        "version": "1.0",
        "x-build-id": "Xz4md6ew4sk8bEoIY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~dba-dk-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-dba-dk-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/logiover~dba-dk-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-dba-dk-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/logiover~dba-dk-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-dba-dk-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": {
                    "searchUrls": {
                        "title": "Search / category URLs",
                        "type": "array",
                        "description": "dba.dk search or category URLs copied straight from the site. Cars: https://www.dba.dk/mobility/search/car?registration_class=1 — General items: https://www.dba.dk/recommerce/forsale/search?q=iphone or a category like https://www.dba.dk/recommerce/forsale/search?category=0.93 (Electronics). Set your filters on dba.dk, then paste the result URL(s) here. Leave empty to scrape used cars by default.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results (total)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Stop after this many listings across all URLs. 0 = no limit (dba.dk caps a single search at 50 pages / ~2600 listings).",
                        "default": 200
                    },
                    "maxResultsPerSearch": {
                        "title": "Max results per search",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap listings per individual search/category URL. 0 = no per-search cap.",
                        "default": 0
                    },
                    "sellerType": {
                        "title": "Seller type filter",
                        "enum": [
                            "any",
                            "private",
                            "dealer"
                        ],
                        "type": "string",
                        "description": "Optionally keep only private sellers or only dealers. 'any' keeps everything the URL returns.",
                        "default": "any"
                    },
                    "useProxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "Route requests through Apify Proxy. Datacenter proxy works reliably on dba.dk and is the default.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy settings. Datacenter is enough for dba.dk; switch to Residential only if you hit blocks.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "maxConcurrency": {
                        "title": "Max concurrent searches",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many search/category URLs to process in parallel.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
