# Bilbasen Scraper (`ivanvs/bilbasen-scraper`) Actor

Extract car listings, prices, specifications, leasing terms, photos, and dealer info from
bilbasen.dk — no login, no cookies, and no proxy setup required

- **URL**: https://apify.com/ivanvs/bilbasen-scraper.md
- **Developed by:** [Gen First](https://apify.com/ivanvs) (community)
- **Categories:** E-commerce, Lead generation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.60 / 1,000 listings

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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Scraper

Extract car listings, prices, specifications, leasing terms, photos, and dealer info from
[bilbasen.dk](https://www.bilbasen.dk/) — no login, no cookies, and no proxy setup required.
Bilbasen Scraper turns any Bilbasen search, single-ad, or dealer URL into clean, structured
JSON you can export to CSV, Excel, JSON, XML, or HTML Table.

### What does Bilbasen Scraper do?

- 🔎 **Scrapes search pages** — paste any Bilbasen search-results URL and collect every listing on it (with automatic pagination).
- 📄 **Scrapes individual ads** — paste a single ad URL to get its full detail record.
- 🏢 **Scrapes dealer pages** — paste a dealer URL to collect every listing that dealer has published.
- 🚗 **Works across all vehicle types** — cars, vans (inkl./ekskl. moms), trucks, buses, and autocampers.
- 🧾 **Returns rich structured data** — title, description, price, images, full technical specifications, equipment list, vehicle ratings, leasing terms, and the dealer's profile.
- 💰 **Captures leasing offers** — monthly payment, first payment, residual value, and contract duration for leasing ads.
- 🔓 **No login or session cookies** required.
- 🌐 **Proxy preconfigured** — uses Apify residential proxy (country `DK`) for reliable performance out of the box.
- 📤 **Export anywhere** — JSON, CSV, Excel, XML, or HTML Table.

### About Bilbasen

Bilbasen.dk is Denmark's largest online marketplace for vehicles. It lists new and used cars,
vans, trucks, buses, and autocampers from both professional dealers and private sellers, with
detailed technical specifications and leasing offers — making it a valuable source of Danish
automotive market and pricing data.

### What can you do with this data?

- **Price monitoring** — track asking prices and leasing rates for specific makes and models over time.
- **Vehicle price comparison** — benchmark prices across many comparable listings by model, year, and mileage.
- **Dealer inventory tracking** — drop a dealer URL to monitor one dealer's full stock.
- **Leasing market analysis** — compare monthly payments, first payments, and residual values across offers.
- **Dataset building** — feed structured listing data into analytics, dashboards, or ML pipelines.

### How to use Bilbasen Scraper

1. Open the actor on Apify.
2. Add one or more Bilbasen URLs to the **urls** field (search pages, single ads, or dealer pages).
3. Set **maxRecords** to cap how many listings to collect (default `100`).
4. Click **Start** and let the scraper run.
5. Download the results in JSON, CSV, Excel, XML, or HTML Table.

#### Input parameters

| Input parameter | Description                                                 | Required | Default value                                                                                   |
| --------------- | ----------------------------------------------------------- | -------- | ----------------------------------------------------------------------------------------------- |
| `urls`          | Bilbasen URLs to scrape (search, single-ad, or dealer URLs) | `true`   | `{ "url": "https://www.bilbasen.dk/brugt/bil/bmw?includeengroscvr=true&includeleasing=false" }` |
| `maxRecords`    | Maximum number of records to scrape                         | `false`  | `100`                                                                                           |

URLs must start with `https://www.bilbasen.dk` — anything else is ignored. Besides typing URLs
directly, the **urls** field accepts a link to a CSV file or a Google Sheet (via
`requestsFromUrl`); the first column of each row is read as a URL.

#### Supported input URLs

Bilbasen Scraper accepts three kinds of URLs:

- **Search URL** — collects every listing on the page (and paginates):
  - `https://www.bilbasen.dk/brugt/bil/bmw?includeengroscvr=true&includeleasing=false`
  - `https://www.bilbasen.dk/brugt/varebil-ekskl-moms?includeengroscvr=true&includeleasing=false`
  - `https://www.bilbasen.dk/brugt/lastbil?pricetype=Leasing&sellertypes=dealer`
  - Vehicle type, make, model, and query filters are all supported. Copy the URL straight from your browser after filtering on Bilbasen.
- **Single ad URL** — collects one listing's full detail record:
  - `https://www.bilbasen.dk/brugt/bil/vw/up/10-75-high-up-3d/6890231`
  - Pattern: the URL ends with the numeric listing id. Works for every vehicle type, e.g. `https://www.bilbasen.dk/brugt/lastbil/scania/p410/6774992`.
- **Dealer URL** — collects every listing from one dealer (and paginates):
  - `https://www.bilbasen.dk/find-en-forhandler/bilforhandler--id22093`
  - Pattern: `https://www.bilbasen.dk/find-en-forhandler/<slug>--id<dealerId>`. Results respect `maxRecords`.

You can mix all three URL types in the same `urls` list. Each output record's `inputUrl` field
is set to the original URL you supplied that produced it.

### Examples

#### Input

Scrape 20 search results from a given search URL:

```json
{
  "urls": ["https://www.bilbasen.dk/brugt/bil/bmw?includeengroscvr=true&includeleasing=false"],
  "maxRecords": 20
}
````

Scrape up to 20 listings from a single dealer:

```json
{
  "urls": ["https://www.bilbasen.dk/find-en-forhandler/bilforhandler--id22093"],
  "maxRecords": 20
}
```

Scrape one specific ad:

```json
{
  "urls": ["https://www.bilbasen.dk/brugt/bil/vw/up/10-75-high-up-3d/6890231"],
  "maxRecords": 1
}
```

#### Output

Search and dealer runs return the **same ad records** as single-ad runs — one record per
listing — with each record's `inputUrl` set to the URL you supplied.

The example below is illustrative: the dealer's identity, address, phone numbers, CVR, website,
and image URLs have been replaced with fictional placeholders, and the `images`, `attributes`,
and `equipment` arrays are shortened. Real records contain the full lists.

```json
{
  "id": "1234567",
  "url": "https://www.bilbasen.dk/brugt/bil/mazda/cx-60/25-phev-takumi-comfort-aut-awd-5d/1234567",
  "title": "Mazda CX-60 2,5 PHEV Takumi Comfort aut. AWD 5d",
  "description": "Velholdt CX-60 PHEV Takumi Comfort med kun 52.000 km. Hvidmetallak, automatgear, læderkabine, 360 parkeringskamera og matrix LED forlygter. Kontakt os for fuld udstyrsliste.",
  "price": 3358,
  "currency": "DKK",
  "brand": "Mazda",
  "model": "CX-60",
  "modelSeries": "2,5 PHEV Takumi Comfort aut. AWD 5d",
  "modelYear": 2022,
  "images": ["https://billeder.bilbasen.dk/bilinfo/<uuid-1>.jpeg?class=S1600X1600", "https://billeder.bilbasen.dk/bilinfo/<uuid-2>.jpeg?class=S1600X1600"],
  "location": {
    "line1": "Eksempelvej 12",
    "line2": "2000 Frederiksberg",
    "zipCode": 2000,
    "city": "Frederiksberg",
    "country": "Danmark"
  },
  "attributes": {
    "Modelår": "2022",
    "1. registrering": "11/2022",
    "Kilometertal": "52.000 km",
    "Drivmiddel": "Plug-in hybrid Benzin",
    "Brændstofforbrug": "(WLTP) 66,7 km/l",
    "Batterikapacitet": "14,5 kWh",
    "CO2 udledning": "33 g/km",
    "Ydelse": "327 hk/500 nm",
    "Geartype": "Automatisk",
    "Farve": "Hvidmetal",
    "Nypris": "503.274 kr.",
    "Type": "SUV",
    "Trækhjul": "Firehjulstræk",
    "Døre": "5"
  },
  "leasing": {
    "Leasing type": "Finansiel, ekskl. moms",
    "Månedlig ydelse": "3.358 kr.",
    "Førstegangsydelse": "40.000 kr.",
    "Totalpris i løbetiden": "80.296 kr.",
    "Restværdi": "(køber hæfter) 330.000 kr.",
    "Løbetid": "12 mdr.",
    "Antal kilometer inkluderet": "Ikke relevant",
    "Forsikring": "Ikke inkluderet",
    "Service og vedligehold": "Ikke inkluderet"
  },
  "vehicleRatings": {
    "average": 3.818181818181818,
    "numberOfReviews": 11,
    "subRatings": [
      { "name": "Køreegenskaber", "rating": 3.5454545454545454 },
      { "name": "Driftsomkostninger", "rating": 3.5454545454545454 },
      { "name": "Sikkerhed", "rating": 4.454545454545454 },
      { "name": "Værdi for pengene", "rating": 3.727272727272727 }
    ]
  },
  "equipment": ["Automatgear", "Adaptiv fartpilot", "360° kamera", "Matrix LED forlygter", "Læderindtræk", "Navigation", "Sædevarme", "Panoramatag"],
  "seller": {
    "id": 10000,
    "name": "Eksempel Biler ApS",
    "type": "Dealer",
    "tenant": "Bilinfo",
    "address": {
      "line1": "Eksempelvej 12",
      "line2": "2000 Frederiksberg",
      "zipCode": 2000,
      "city": "Frederiksberg",
      "country": "Danmark"
    },
    "phoneNumbers": [
      { "info": "", "number": "00000000" },
      { "info": "", "number": "00000001" }
    ],
    "sellerOtherItems": {
      "url": "https://www.bilbasen.dk/find-en-forhandler/bilforhandler--id10000",
      "numberOfListings": 29
    },
    "features": {
      "isNemIdValidated": false,
      "website": "https://www.example.dk",
      "dealerProfile": {
        "topLogo": { "url": "https://billeder.bilbasen.dk/bilinfo/<uuid-3>.jpg?class=S400X400" },
        "image": { "url": "https://billeder.bilbasen.dk/bilinfo/<uuid-4>.jpeg?class=S400X400" },
        "logo": { "url": "https://billeder.bilbasen.dk/bilinfo/<uuid-5>.jpg?class=S400X400" },
        "description": "Vi er en leasingforhandler med fokus på gennemsigtige aftaler. Du er altid velkommen i vores garage til en snak om biler.",
        "youTubeVideoId": "",
        "uniqueSellingPoints": ["Fri kilometer i hele leasingperioden", "Kaskoforsikring på alle biler", "Perioder på 6, 12, 24 eller 36 mdr."],
        "openingHours": [
          { "key": "Mandag - Torsdag", "value": "9:00 - 17:00" },
          { "key": "Fredag", "value": "9:00 - 16:30" },
          { "key": "Lørdag - Søndag", "value": "Efter aftale" }
        ]
      },
      "eidValidation": "None",
      "cvr": "12345678"
    },
    "hasEmail": true,
    "phoneNumberType": "DynamicVirtual",
    "dsaText": "Forhandleren har accepteret, at de kun annoncerer i overensstemmelse med gældende lovgivning."
  },
  "inputUrl": "https://www.bilbasen.dk/find-en-forhandler/bilforhandler--id10000"
}
```

### Output fields

Each scraped listing is one dataset record (stored in the `ad_details` dataset). Most fields are
optional and may be `null` when Bilbasen does not provide a value.

| Field            | Description                                                                            |
| ---------------- | -------------------------------------------------------------------------------------- |
| `id`             | Bilbasen listing ID (e.g. `1234567`).                                                  |
| `url`            | Canonical URL of the ad.                                                               |
| `title`          | Listing title, composed as make + model + variant.                                     |
| `description`    | Full listing description text (newlines preserved).                                    |
| `price`          | Price as a number. For leasing ads this is the monthly payment.                        |
| `currency`       | Currency code (`DKK`).                                                                 |
| `brand`          | Vehicle make (e.g. `Mazda`).                                                           |
| `model`          | Vehicle model (e.g. `CX-60`).                                                          |
| `modelSeries`    | Variant / trim description (e.g. `2,5 PHEV Takumi Comfort aut. AWD 5d`).               |
| `modelYear`      | Model year as a number.                                                                |
| `images`         | Array of full-size image URLs.                                                         |
| `location`       | Where the vehicle is located: `line1`, `line2`, `zipCode`, `city`, `country`.          |
| `attributes`     | Flat map of technical specifications — see below.                                      |
| `leasing`        | Flat map of leasing terms, or `null` — see below.                                      |
| `vehicleRatings` | Model review scores: `average`, `numberOfReviews`, and `subRatings`.                   |
| `equipment`      | Array of equipment and options on the vehicle.                                         |
| `seller`         | The seller's full record: name, type, address, phone numbers, CVR, and dealer profile. |
| `inputUrl`       | The original URL you supplied that produced this record.                               |

#### `attributes`

A flat key→value map (`Record<string, string>`) of the vehicle's technical specifications, with
Danish keys taken straight from Bilbasen — for example `Kilometertal`, `Drivmiddel`, `Geartype`,
`Ydelse`, `CO2 udledning`, `Nypris`, and `Farve`. Values are display strings including their unit
(`"52.000 km"`, `"33 g/km"`). The exact set of keys varies by vehicle type and drivetrain: electric
and plug-in hybrid listings add keys like `Batterikapacitet` and `Rækkevidde`.

#### `leasing`

Present only on leasing ads; `null` otherwise. Same flat key→value shape as `attributes`, with
keys such as `Månedlig ydelse`, `Førstegangsydelse`, `Restværdi`, `Løbetid`, and `Forsikring`.

### Output formats

Results are stored in an Apify dataset (`ad_details`). After a run finishes you can download the
data as **JSON, CSV, Excel, XML, or HTML Table**, or pull it via the Apify API.

### ❓ FAQ

#### Do I need proxies to scrape Bilbasen?

No. The actor is preconfigured to use Apify proxy for optimal
performance — you don't need to set anything up.

#### Do I need to write code?

No. Bilbasen Scraper is a no-code tool: paste your URLs, set `maxRecords`, and run.

#### Can I scrape a single ad or a whole search?

Both. Provide a search URL to collect many listings, or a single ad URL to collect one listing's
full record. You can mix search, single-ad, and dealer URLs in the same `urls` list.

#### Can I scrape every listing from one dealer?

Yes. Paste the dealer's URL — `https://www.bilbasen.dk/find-en-forhandler/<slug>--id<dealerId>` —
and the scraper collects that dealer's listings, up to `maxRecords`. Each result is a full ad
record, identical to single-ad output, with `inputUrl` set to the dealer URL.

#### How many listings can I scrape?

Use `maxRecords` to set the cap (default `100`). Increase it to collect more results across
paginated search and dealer pages.

#### Does it work for vans, trucks, and autocampers?

Yes. Any Bilbasen vehicle type works — `bil`, `varebil-inkl-moms`, `varebil-ekskl-moms`,
`lastbil`, `bus`, and `autocamper` — for both search and single-ad URLs.

#### Does it capture leasing offers?

Yes. Leasing ads include a `leasing` object with the monthly payment, first payment, residual
value, contract duration, and what's included. On these ads, `price` is the monthly payment.

#### What if an ad can't be scraped?

The record is still written, as `{ inputUrl, url, title: "AD not found" }`, so you can tell
missing listings apart from silent gaps.

#### Is it legal to scrape Bilbasen?

Scraping publicly available data is generally permitted, but you are responsible for how you use
it. Listings include dealer contact details, which are personal data under the GDPR. Avoid
collecting or storing personal data beyond what your use case requires, and comply with
applicable laws and Bilbasen's terms. Consult legal counsel if you're unsure.

#### What export formats are available?

JSON, CSV, Excel, XML, and HTML Table — plus programmatic access via the Apify API.

### Support

For custom or simplified outputs, or to report a bug, contact the developer at
**support (at) getmediumdata.com** or open an issue.

# Actor input Schema

## `maxRecords` (type: `integer`):

Maximum number of records to be scraped

## `urls` (type: `array`):

List of URLs from Bilbasen (https://www.bilbasen.dk) that needs to be scraped

## Actor input object example

```json
{
  "maxRecords": 10,
  "urls": [
    {
      "url": "https://www.bilbasen.dk/brugt/bil/bmw?includeengroscvr=true&includeleasing=false"
    }
  ]
}
```

# 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 = {
    "maxRecords": 10,
    "urls": [
        {
            "url": "https://www.bilbasen.dk/brugt/bil/bmw?includeengroscvr=true&includeleasing=false"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("ivanvs/bilbasen-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 = {
    "maxRecords": 10,
    "urls": [{ "url": "https://www.bilbasen.dk/brugt/bil/bmw?includeengroscvr=true&includeleasing=false" }],
}

# Run the Actor and wait for it to finish
run = client.actor("ivanvs/bilbasen-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 '{
  "maxRecords": 10,
  "urls": [
    {
      "url": "https://www.bilbasen.dk/brugt/bil/bmw?includeengroscvr=true&includeleasing=false"
    }
  ]
}' |
apify call ivanvs/bilbasen-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bilbasen Scraper",
        "description": "Extract car listings, prices, specifications, leasing terms, photos, and dealer info from\nbilbasen.dk — no login, no cookies, and no proxy setup required",
        "version": "0.0",
        "x-build-id": "gGjohjk5KttMvX458"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ivanvs~bilbasen-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ivanvs-bilbasen-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/ivanvs~bilbasen-scraper/runs": {
            "post": {
                "operationId": "runs-sync-ivanvs-bilbasen-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/ivanvs~bilbasen-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-ivanvs-bilbasen-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",
                "required": [
                    "urls"
                ],
                "properties": {
                    "maxRecords": {
                        "title": "Maximum number of records",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of records to be scraped",
                        "default": 100
                    },
                    "urls": {
                        "title": "List of URLs",
                        "type": "array",
                        "description": "List of URLs from Bilbasen (https://www.bilbasen.dk) that needs to be scraped",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
