# Bilbasen.dk Scraper (`solidcode/bilbasen-dk-scraper`) Actor

\[💰 $1.5 / 1K] Extract new and used car listings from Bilbasen.dk, Denmark's largest car marketplace — price, mileage, year, specs (horsepower, fuel, gearbox, EV range & battery, tax), location, photos, and optional monthly finance price. Search by make/model + filters, postal code, or any URL.

- **URL**: https://apify.com/solidcode/bilbasen-dk-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (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 $1.50 / 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

## Bilbasen.dk Scraper

Pull new and used car listings from Bilbasen.dk at scale — make, model, variant, price in DKK, mileage, registration year, horsepower, 0–100 km/h acceleration, yearly ownership tax, fuel and gearbox, location, and every listing photo, all in one flat row per car. Electric and plug-in hybrid cars also carry their driving range and battery capacity. Search by make and model, scope to a postal code and radius, or paste any Bilbasen search or listing URL. Built for Danish car dealers, automotive market researchers, and lead-generation teams who need fresh Bilbasen inventory data without copy-pasting listings by hand.

### Why This Scraper?

- **Paginate the full Danish national inventory** — sweep every page of a search, not just the first one, with `maxResults` up to 100,000 cars per run.
- **Seven fuel-type categories** — Petrol, Diesel, Electric, Hybrid (Petrol or Diesel), and Plug-in Hybrid (Petrol or Diesel) as a multi-select, so EV and PHEV pulls stay clean.
- **EV-ready spec fields** — every electric and plug-in hybrid row carries its driving range (`rangeKm`) and battery capacity (`batteryKwh`), alongside 0–100 km/h acceleration, yearly ownership tax (ejerafgift), and tow weight for every car.
- **Ten body-type filters** — Micro, Hatchback, Sedan, Station wagon, SUV, Crossover, MPV, Coupé, Convertible, and Van (the Van category is handled separately under the hood).
- **Retail and leasing prices side by side** — every row carries the numeric DKK price, the formatted price text, and a `priceType` of Retail or Leasing.
- **Optional monthly finance price** — flip on `includeFinancing` to add the lowest available monthly instalment (`monthlyPrice`, in DKK) to each car from Bilbasen's own financing calculator.
- **Postal-code radius search up to 200 km** — center a search on any Danish postal code (e.g. 2100 Copenhagen, 8000 Aarhus) and pull cars within 10, 25, 50, 100, 150, or 200 km.
- **Seven sort orders** — relevance, price low-to-high or high-to-low, year newest or oldest, mileage low-to-high, or recently listed, so you can grab the freshest or cheapest cars first.
- **Every listing photo, inlined** — each row carries an `images` array of full-resolution photo URLs plus an `imageCount`, no second request needed.
- **Dealer or private seller filter** — restrict to professional dealers (Forhandler) or private sellers in a single dropdown, with `sellerType` on every row.

### Use Cases

**Market Research**
- Track new and used car pricing across makes, models, and fuel types in Denmark
- Compare EV and plug-in hybrid inventory against petrol and diesel supply
- Measure how mileage and registration year move asking prices in DKK
- Monitor national inventory levels for a model over time

**Dealer Intelligence**
- See what competing dealers list, at what price, and how long it stays up
- Benchmark your own stock against the wider Bilbasen market
- Spot pricing gaps by body type, fuel type, or region

**Lead Generation**
- Build prospect lists of private sellers within a postal-code radius
- Source trade-in and acquisition targets by make, model, and mileage
- Filter to a region with postal code + radius for local outreach

**Price Monitoring**
- Watch retail and leasing prices on specific models week over week
- Track monthly finance instalments with the financing add-on
- Flag underpriced or overpriced listings against the market median

### Getting Started

#### Search by Make and Model

The simplest way to start — one make and model:

```json
{
    "make": "Audi",
    "model": "A4",
    "maxResults": 50
}
````

#### Filtered Search

Combine the most useful filters — electric SUVs from dealers, cheapest first:

```json
{
    "fuelType": ["el"],
    "bodyType": ["suv"],
    "sellerType": "dealer",
    "sortBy": "priceAsc",
    "maxResults": 100
}
```

#### Postal Code + Radius with Finance Prices

Scope to a region and add the monthly finance instalment to each car:

```json
{
    "make": "Volkswagen",
    "zipCode": "8000",
    "radiusKm": "50",
    "includeFinancing": true,
    "maxResults": 100
}
```

#### Using a Bilbasen URL

Set your filters on bilbasen.dk, copy the address bar, and paste it — the URL takes priority over the fields above:

```json
{
    "startUrls": ["https://www.bilbasen.dk/brugt/bil/audi/a4"],
    "maxResults": 100
}
```

#### Full-Featured Example

```json
{
    "make": "Volkswagen",
    "model": "Golf",
    "fuelType": ["benzin"],
    "bodyType": ["hatchback"],
    "gearType": "manuel",
    "sellerType": "dealer",
    "priceType": "retail",
    "priceMin": 50000,
    "priceMax": 250000,
    "yearMin": 2015,
    "yearMax": 2023,
    "mileageMax": 150000,
    "zipCode": "2100",
    "radiusKm": "200",
    "sortBy": "yearDesc",
    "includeFinancing": true,
    "maxResults": 500
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | string\[] | `[]` | One or more Bilbasen.dk search-result or individual car-listing URLs. When provided, these are used directly and the search fields below are ignored. |

#### Build a Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `make` | string | `""` | Car manufacturer as shown on Bilbasen, e.g. Audi, Volkswagen, Tesla. Leave empty for all makes. |
| `model` | string | `""` | Model name (must match the chosen make), e.g. A4, Golf, Model 3. Leave empty for all models. |
| `fuelType` | string\[] | `[]` | Petrol (Benzin), Diesel, Electric (El), Hybrid – Petrol, Hybrid – Diesel, Plug-in Hybrid – Petrol, Plug-in Hybrid – Diesel. Multi-select. |
| `bodyType` | string\[] | `[]` | Micro, Hatchback, Sedan, Station wagon (Stationcar), SUV, Crossover (CUV), MPV / Minivan, Coupé, Convertible (Cabriolet), Van. Multi-select. |
| `gearType` | select | `Any` | Gearbox: Any, Manual (Manuel), or Automatic (Automatisk). |
| `sellerType` | select | `Any` | Who is selling: Any, Dealer (Forhandler), or Private. |
| `priceType` | select | `Any` | Any, Retail (cash price), or Leasing (monthly). |
| `sortBy` | select | `Relevance` | Result order: Relevance, Price low-to-high, Price high-to-low, Year newest, Year oldest, Mileage low-to-high, or Recently listed. |

#### Price, Year & Mileage

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `priceMin` | integer | `null` | Only include cars at or above this price, in Danish kroner. |
| `priceMax` | integer | `null` | Only include cars at or below this price, in Danish kroner. |
| `yearMin` | integer | `null` | Only include cars first registered in or after this year, e.g. 2018. |
| `yearMax` | integer | `null` | Only include cars first registered in or before this year. |
| `mileageMax` | integer | `null` | Only include cars with at most this many kilometers on the odometer. |

#### Location

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `zipCode` | string | `""` | Danish postal code to search around, e.g. 2100 (Copenhagen) or 8000 (Aarhus). Used together with Search radius. |
| `radiusKm` | select | `100 km` | How far around the postal code to search: 10, 25, 50, 100, 150, or 200 km. Only applies when a postal code is set. |

#### Output

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeFinancing` | boolean | `false` | When enabled, each car is also looked up against Bilbasen's financing calculator to add the lowest available monthly instalment (`monthlyPrice`). Adds an extra lookup per car. |
| `maxResults` | integer | `100` | Maximum number of listings to return per search or URL. Set to 0 for unlimited (subject to Bilbasen's pagination ceiling). |

### Output

Each car is one flat row. Here's a representative result with the financing add-on enabled:

```json
{
    "listingId": "6872868",
    "url": "https://www.bilbasen.dk/brugt/bil/audi/a4/...",
    "title": "Audi A4 2,0 TFSI Sport",
    "make": "Audi",
    "model": "A4",
    "variant": "2,0 TFSI Sport",
    "year": 2020,
    "firstRegistration": "4/2020",
    "mileage": 68000,
    "price": 329900,
    "priceText": "329.900 kr.",
    "priceType": "Retail",
    "monthlyPrice": 4312.50,
    "fuelType": "Benzin",
    "gearType": "Automatisk",
    "doors": 4,
    "horsepower": 190,
    "accelerationSec": 7.3,
    "yearlyTax": 5980,
    "towWeight": 1800,
    "rangeKm": null,
    "batteryKwh": null,
    "description": "Velholdt Audi A4 med fuld servicehistorik...",
    "sellerType": "Forhandler",
    "location": "København, Hovedstaden",
    "zipCode": "2100",
    "images": ["https://billeder.bilbasen.dk/...jpg"],
    "imageCount": 12,
    "scrapedAt": "2026-06-26T14:30:00Z"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `listingId` | string | Unique Bilbasen listing identifier |
| `url` | string | Direct Bilbasen listing URL |
| `title` | string | Listing headline (make, model, and variant combined) |
| `make` | string | Manufacturer |
| `model` | string | Model name |
| `variant` | string | Trim / variant text |
| `description` | string | Seller's free-text description |
| `scrapedAt` | string | ISO timestamp of data extraction |

#### Specifications

| Field | Type | Description |
|-------|------|-------------|
| `year` | number | Registration year |
| `firstRegistration` | string | First-registration date or month |
| `mileage` | number | Odometer reading in kilometers |
| `fuelType` | string | Benzin, Diesel, El, Hybrid, or Plug-in hybrid |
| `gearType` | string | Manuel or Automatisk |
| `doors` | number | Number of doors |
| `horsepower` | number | Engine power in HP (hk) |
| `accelerationSec` | number | 0–100 km/h acceleration time in seconds |
| `yearlyTax` | number | Annual ownership tax (ejerafgift) in DKK per year |
| `towWeight` | number | Maximum towing weight in kg |
| `rangeKm` | number | Electric driving range in km (electric and plug-in hybrid cars) |
| `batteryKwh` | number | Battery capacity in kWh (electric and plug-in hybrid cars) |

#### Price & Seller

| Field | Type | Description |
|-------|------|-------------|
| `price` | number | Numeric price in DKK |
| `priceText` | string | Formatted price as shown on Bilbasen |
| `priceType` | string | Retail or Leasing |
| `monthlyPrice` | number | Lowest monthly finance instalment in DKK (populated when `includeFinancing` is on) |
| `sellerType` | string | Forhandler (dealer) or Private |
| `location` | string | City and region |
| `zipCode` | string | Danish postal code |

#### Photos

| Field | Type | Description |
|-------|------|-------------|
| `images` | string\[] | All listing photo URLs |
| `imageCount` | number | Number of photos |

### Tips for Best Results

- **Start small** — set `maxResults` to 30–50 on your first run to confirm the data matches your needs, then scale up.
- **URLs override the search fields** — if you paste a Bilbasen URL into `startUrls`, the make, model, and filter fields are ignored. Use one approach or the other, not both.
- **Scope to a region with postal code + radius** — set `zipCode` plus `radiusKm` to pull only cars near a city; the radius is ignored unless a postal code is set.
- **Leave the finance add-on off for speed** — `includeFinancing` adds a per-car lookup, so keep it off unless you actually need the `monthlyPrice` field.
- **Sort by Recently listed for fresh stock** — set `sortBy` to "Recently listed" to surface the newest listings first, ideal for daily monitoring runs.
- **Search vans on their own** — the Van body type uses Bilbasen's separate van category, so run it as its own job rather than mixing it with passenger-car body types.
- **Make and model match Bilbasen's spelling** — use the names exactly as they appear on the site (e.g. Citroën, Škoda, Mercedes-Benz) for the tightest results.

### Pricing

**From $1.50 per 1,000 results** — flat pay-per-result pricing that undercuts the per-run-fee model most car-listing scrapers use. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows the total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.18 | $0.17 | $0.16 | $0.15 |
| 1,000 | $1.80 | $1.70 | $1.60 | $1.50 |
| 10,000 | $18.00 | $17.00 | $16.00 | $15.00 |
| 100,000 | $180.00 | $170.00 | $160.00 | $150.00 |

A "result" is any car listing row in the output dataset. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate automotive market research, dealer intelligence, and lead generation. Users are responsible for complying with applicable laws and Bilbasen.dk's Terms of Service. Do not use extracted data for spam, harassment, or any unlawful purpose, and handle any personal data in line with GDPR and other applicable privacy regulations. </content> </invoke>

# Actor input Schema

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

Paste one or more Bilbasen.dk search-result URLs or individual car-listing URLs (e.g. 'https://www.bilbasen.dk/brugt/bil/audi/a4' or a single car page). Go to bilbasen.dk, set your filters in the browser, and copy the URL from the address bar. When provided, these are used directly and the search fields below are ignored.

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

Car manufacturer as shown on Bilbasen, e.g. 'Audi', 'Volkswagen', 'Tesla'. Leave empty for all makes. Ignored when Bilbasen URLs are provided.

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

Model name as shown on Bilbasen (must match the chosen Make), e.g. 'A4', 'Golf', 'Model 3'. Leave empty for all models of the chosen make.

## `fuelType` (type: `array`):

Only include cars with these fuel types. Leave empty for all fuel types.

## `bodyType` (type: `array`):

Only include cars with these body types. Leave empty for all body types. Note: selecting 'Van' searches the separate van category and is best used on its own.

## `gearType` (type: `string`):

Gearbox type.

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

Filter listings by who is selling.

## `priceType` (type: `string`):

Which kind of price to filter on. 'Retail' is a normal cash purchase, 'Leasing' is a monthly lease offer.

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

Only include cars at or above this price, in Danish kroner. Leave empty for no lower bound.

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

Only include cars at or below this price, in Danish kroner. Leave empty for no upper bound.

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

Only include cars first registered in or after this year, e.g. 2018. Leave empty for any age.

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

Only include cars first registered in or before this year. Leave empty for any age.

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

Only include cars with at most this many kilometers on the odometer, e.g. 100000. Leave empty for any mileage.

## `zipCode` (type: `string`):

Danish postal code to search around, e.g. '2100' (Copenhagen) or '8000' (Aarhus). Used together with Search radius. Leave empty to search all of Denmark.

## `radiusKm` (type: `string`):

How far around the postal code to search, in kilometers. Only applies when a postal code is set.

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

How to order the search results. Defaults to Bilbasen's relevance ranking.

## `includeFinancing` (type: `boolean`):

When enabled, every car is also looked up against Bilbasen's financing calculator to add the lowest available monthly finance instalment (monthlyPrice) to each row. This adds an extra lookup per car, so the run takes a little longer. Leave off for the fastest run.

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

Maximum number of car listings to return per search or URL. The actor may return a few extra from the final page — it stops requesting new pages once the cap is reached. Set to 0 for unlimited (subject to Bilbasen's pagination ceiling).

## Actor input object example

```json
{
  "startUrls": [
    "https://www.bilbasen.dk/brugt/bil/audi/a4"
  ],
  "fuelType": [],
  "bodyType": [],
  "gearType": "any",
  "sellerType": "any",
  "priceType": "any",
  "radiusKm": "100",
  "sortBy": "relevance",
  "includeFinancing": false,
  "maxResults": 100
}
```

# Actor output Schema

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

Table of car listings with key fields like make, model, year, price, mileage, and location.

## `details` (type: `string`):

Full per-listing detail rows including specifications, pricing, seller type, location, and photos.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        "https://www.bilbasen.dk/brugt/bil/audi/a4"
    ],
    "make": "",
    "model": "",
    "fuelType": [],
    "bodyType": [],
    "gearType": "any",
    "sellerType": "any",
    "priceType": "any",
    "zipCode": "",
    "radiusKm": "100",
    "sortBy": "relevance",
    "includeFinancing": false,
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/bilbasen-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 = {
    "startUrls": ["https://www.bilbasen.dk/brugt/bil/audi/a4"],
    "make": "",
    "model": "",
    "fuelType": [],
    "bodyType": [],
    "gearType": "any",
    "sellerType": "any",
    "priceType": "any",
    "zipCode": "",
    "radiusKm": "100",
    "sortBy": "relevance",
    "includeFinancing": False,
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/bilbasen-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 '{
  "startUrls": [
    "https://www.bilbasen.dk/brugt/bil/audi/a4"
  ],
  "make": "",
  "model": "",
  "fuelType": [],
  "bodyType": [],
  "gearType": "any",
  "sellerType": "any",
  "priceType": "any",
  "zipCode": "",
  "radiusKm": "100",
  "sortBy": "relevance",
  "includeFinancing": false,
  "maxResults": 100
}' |
apify call solidcode/bilbasen-dk-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bilbasen.dk Scraper",
        "description": "[💰 $1.5 / 1K] Extract new and used car listings from Bilbasen.dk, Denmark's largest car marketplace — price, mileage, year, specs (horsepower, fuel, gearbox, EV range & battery, tax), location, photos, and optional monthly finance price. Search by make/model + filters, postal code, or any URL.",
        "version": "1.0",
        "x-build-id": "u01kbVu4FGl3DOWMt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~bilbasen-dk-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-bilbasen-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/solidcode~bilbasen-dk-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-bilbasen-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/solidcode~bilbasen-dk-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-bilbasen-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": {
                    "startUrls": {
                        "title": "Bilbasen URLs",
                        "type": "array",
                        "description": "Paste one or more Bilbasen.dk search-result URLs or individual car-listing URLs (e.g. 'https://www.bilbasen.dk/brugt/bil/audi/a4' or a single car page). Go to bilbasen.dk, set your filters in the browser, and copy the URL from the address bar. When provided, these are used directly and the search fields below are ignored.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "make": {
                        "title": "Make",
                        "type": "string",
                        "description": "Car manufacturer as shown on Bilbasen, e.g. 'Audi', 'Volkswagen', 'Tesla'. Leave empty for all makes. Ignored when Bilbasen URLs are provided."
                    },
                    "model": {
                        "title": "Model",
                        "type": "string",
                        "description": "Model name as shown on Bilbasen (must match the chosen Make), e.g. 'A4', 'Golf', 'Model 3'. Leave empty for all models of the chosen make."
                    },
                    "fuelType": {
                        "title": "Fuel type",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include cars with these fuel types. Leave empty for all fuel types.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "benzin",
                                "diesel",
                                "el",
                                "hybrid-benzin",
                                "hybrid-diesel",
                                "plugin-hybrid-benzin",
                                "plugin-hybrid-diesel"
                            ],
                            "enumTitles": [
                                "Petrol (Benzin)",
                                "Diesel",
                                "Electric (El)",
                                "Hybrid – Petrol",
                                "Hybrid – Diesel",
                                "Plug-in Hybrid – Petrol",
                                "Plug-in Hybrid – Diesel"
                            ]
                        }
                    },
                    "bodyType": {
                        "title": "Body type",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include cars with these body types. Leave empty for all body types. Note: selecting 'Van' searches the separate van category and is best used on its own.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "micro",
                                "hatchback",
                                "sedan",
                                "stationcar",
                                "suv",
                                "cuv",
                                "mpv",
                                "coupe",
                                "cabriolet",
                                "van"
                            ],
                            "enumTitles": [
                                "Micro",
                                "Hatchback",
                                "Sedan",
                                "Station wagon (Stationcar)",
                                "SUV",
                                "Crossover (CUV)",
                                "MPV / Minivan",
                                "Coupé",
                                "Convertible (Cabriolet)",
                                "Van"
                            ]
                        }
                    },
                    "gearType": {
                        "title": "Transmission",
                        "enum": [
                            "any",
                            "manuel",
                            "automatisk"
                        ],
                        "type": "string",
                        "description": "Gearbox type.",
                        "default": "any"
                    },
                    "sellerType": {
                        "title": "Seller type",
                        "enum": [
                            "any",
                            "dealer",
                            "private"
                        ],
                        "type": "string",
                        "description": "Filter listings by who is selling.",
                        "default": "any"
                    },
                    "priceType": {
                        "title": "Price type",
                        "enum": [
                            "any",
                            "retail",
                            "leasing"
                        ],
                        "type": "string",
                        "description": "Which kind of price to filter on. 'Retail' is a normal cash purchase, 'Leasing' is a monthly lease offer.",
                        "default": "any"
                    },
                    "priceMin": {
                        "title": "Minimum price (DKK)",
                        "minimum": 0,
                        "maximum": 20000000,
                        "type": "integer",
                        "description": "Only include cars at or above this price, in Danish kroner. Leave empty for no lower bound."
                    },
                    "priceMax": {
                        "title": "Maximum price (DKK)",
                        "minimum": 0,
                        "maximum": 20000000,
                        "type": "integer",
                        "description": "Only include cars at or below this price, in Danish kroner. Leave empty for no upper bound."
                    },
                    "yearMin": {
                        "title": "Minimum year",
                        "minimum": 1900,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Only include cars first registered in or after this year, e.g. 2018. Leave empty for any age."
                    },
                    "yearMax": {
                        "title": "Maximum year",
                        "minimum": 1900,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Only include cars first registered in or before this year. Leave empty for any age."
                    },
                    "mileageMax": {
                        "title": "Maximum mileage (km)",
                        "minimum": 0,
                        "maximum": 2000000,
                        "type": "integer",
                        "description": "Only include cars with at most this many kilometers on the odometer, e.g. 100000. Leave empty for any mileage."
                    },
                    "zipCode": {
                        "title": "Postal code",
                        "type": "string",
                        "description": "Danish postal code to search around, e.g. '2100' (Copenhagen) or '8000' (Aarhus). Used together with Search radius. Leave empty to search all of Denmark."
                    },
                    "radiusKm": {
                        "title": "Search radius (km)",
                        "enum": [
                            "10",
                            "25",
                            "50",
                            "100",
                            "150",
                            "200"
                        ],
                        "type": "string",
                        "description": "How far around the postal code to search, in kilometers. Only applies when a postal code is set.",
                        "default": "100"
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "priceAsc",
                            "priceDesc",
                            "yearDesc",
                            "yearAsc",
                            "mileageAsc",
                            "newest"
                        ],
                        "type": "string",
                        "description": "How to order the search results. Defaults to Bilbasen's relevance ranking.",
                        "default": "relevance"
                    },
                    "includeFinancing": {
                        "title": "Include monthly finance price",
                        "type": "boolean",
                        "description": "When enabled, every car is also looked up against Bilbasen's financing calculator to add the lowest available monthly finance instalment (monthlyPrice) to each row. This adds an extra lookup per car, so the run takes a little longer. Leave off for the fastest run.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of car listings to return per search or URL. The actor may return a few extra from the final page — it stops requesting new pages once the cap is reached. Set to 0 for unlimited (subject to Bilbasen's pagination ceiling).",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
