# European Auction Results — Troostwijk & Vavato (`blip-automation/european-auction-results`) Actor

Vehicle and machinery lots from Troostwijk and Vavato with sold/unsold outcomes and realised hammer prices.

- **URL**: https://apify.com/blip-automation/european-auction-results.md
- **Developed by:** [Rokas Simkus](https://apify.com/blip-automation) (community)
- **Categories:** E-commerce, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

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

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

# README

## European Auction Results — Troostwijk & Vavato

Scrape vehicle and machinery lots from **Troostwijk Auctions** and **Vavato**, two of the
largest industrial auction houses in Europe — including, for finished auctions, **whether each
lot actually sold and for how much**.

Most European auction data is locked behind a dealer login. This Actor covers two houses that
publish their results openly, and reports them without guessing.

### Why sold-vs-unsold is the point

On a finished auction, every lot shows a bid amount — including the lots that never sold
because the reserve was not met. They look identical in the page data. On a sample vehicle
auction, **30 of 48 finished lots did not sell**, yet all 48 carried a bid figure.

A scraper that treats "auction closed + has a bid" as a sale therefore invents price history
for the majority of its rows. This Actor reads the auction house's own sale term for every lot
and reports the outcome explicitly:

| Field | Meaning |
|---|---|
| `saleOutcome` | `sold`, `unsold`, `pending` (still live) or `unknown` |
| `priceEurAmount` | the figure, whatever it represents |
| `priceType` | `hammer` for a completed sale, `current_bid` otherwise |
| `reserveMet` | whether the reserve was reached, where the source says |
| `priceEur` | populated **only** for confirmed sales, so averages stay clean |
| `sourceSaleTerm` | the house's raw term, so you can audit the mapping yourself |

Unsold lots are kept, not dropped — "the market would not go above €X" is real information if
you are pricing inventory.

### What you get per lot

Lot number, title, make, model, year, current or final amount in EUR, bid count, auction
start and end times, city and country, lot URL, image, auction id, and the raw status fields.

Vehicle make and model are only filled in when the marque is actually recognised. An
unrecognised title leaves them `null` rather than putting the whole title in the `make`
column — a null is honest, a wrong value quietly corrupts whatever you group by.

### Coverage

Both brands run one platform, so a single run can cover both. Vehicle categories: cars,
trucks and trailers, off-road vehicles, motorcycles and quads, campers, trailers, army
vehicles. Non-vehicle categories (construction and earthmoving, agricultural, boats) are
available but off by default, because they dilute a vehicle dataset.

At the time of writing the Cars category alone held **2,743 lots**.

### Typical uses

- **Residual value and price guides** — realised prices, not asking prices.
- **Dealer sourcing** — monitor live lots by category and country, only what is new.
- **Market research** — sell-through rates by make, model, country and month, which is only
  computable because unsold lots are reported rather than silently dropped.

### Monitoring mode

Turn on **Only lots not seen in a previous run** and schedule it. The Actor remembers lot IDs
between runs and returns only new lots, so a daily run is small and cheap.

### Pricing

Pay per event. Live lots and finished lots with a resolved outcome are billed separately,
because they are worth different amounts — you are not charged a premium rate for inventory
you could have seen on the site.

There is no per-run start fee, and no charge for a run that returns nothing.

### Notes on access and data

- Only pages the sites' `robots.txt` permits are requested, and that file is re-read and
  re-checked on **every run** rather than assumed from when this Actor was written. If the
  policy changes, the Actor stops.
- These are **lots, not people**. No seller names, phone numbers or email addresses are
  collected, and free-text fields are scrubbed of contact details before output.
- No login, no paywall and no bot-protection bypass is involved.
- Requests are rate-limited and run without a proxy by default.

Source: [troostwijkauctions.com](https://www.troostwijkauctions.com) and
[vavato.com](https://www.vavato.com). Not affiliated with, endorsed by, or connected to
TBAuctions. If you represent either site and want this changed or removed, open an issue on
this Actor and it will be actioned.

# Actor input Schema

## `site` (type: `string`):

Troostwijk and Vavato are sister brands on one platform. Scraping both gives the widest inventory.

## `categories` (type: `array`):

Which categories to crawl. Cars and Trucks are the vehicle categories. The broad 'Transport and logistics' parent also contains racking, warehouse inventory and lifting gear, so it is not a default.

## `saleStatus` (type: `string`):

Closed lots carry a resolved outcome — this is the data that is hard to get anywhere else. Live lots show what is currently on the market.

## `maxLots` (type: `integer`):

Stop after this many lots. Start small to see the data shape before running a large job.

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

Optional. Paste Troostwijk or Vavato auction (/a/) or category (/c/) URLs to scrape exactly those instead of the categories above.

## `onlyNewSinceLastRun` (type: `boolean`):

Remembers lot IDs between runs, so a scheduled run returns only what is new. Ideal for monitoring; leave off for a one-off export.

## `maxPagesPerTarget` (type: `integer`):

Safety cap on pagination depth. Each page holds up to 48 lots.

## `proxyTier` (type: `string`):

These sites have no bot protection, so no proxy is needed and none is the cheapest, fastest option. Only escalate if you see failures.

## Actor input object example

```json
{
  "site": "both",
  "categories": [
    "cars"
  ],
  "saleStatus": "all",
  "maxLots": 50,
  "startUrls": [],
  "onlyNewSinceLastRun": false,
  "maxPagesPerTarget": 25,
  "proxyTier": "none"
}
```

# 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 = {
    "categories": [
        "cars"
    ],
    "maxLots": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("blip-automation/european-auction-results").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 = {
    "categories": ["cars"],
    "maxLots": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("blip-automation/european-auction-results").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 '{
  "categories": [
    "cars"
  ],
  "maxLots": 50
}' |
apify call blip-automation/european-auction-results --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=blip-automation/european-auction-results",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/ZtfcTFi5f0dBfr55H/builds/aKb2FQUb6GfJCdb7K/openapi.json