# IAAI Import Calculator Poland: Landed Cost & Profit (`donzely/iaai-import-calculator-poland`) Actor

Scrape live IAAI auction lots and get the full cost of importing each car from the USA to Poland: auction fees, transport, shipping, EU duty, VAT, Polish excise (akcyza) and repair. Compares with Otomoto.pl prices to show profit, ROI and your maximum bid.

- **URL**: https://apify.com/donzely/iaai-import-calculator-poland.md
- **Developed by:** [Grzegorz Pryjma](https://apify.com/donzely) (community)
- **Categories:** Automation, E-commerce
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.50 / 1,000 analyzed lots

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## IAAI Import Calculator Poland – US Car Landed Cost & Otomoto Profit

**Find profitable cars to import from US auctions to Poland in minutes.** This Actor scrapes live **IAAI (Insurance Auto Auctions)** lots, calculates the **full landed cost of importing each car to Poland**, and compares it with **real Otomoto.pl market prices** of the same undamaged model. For every lot you get the estimated profit, ROI and the **maximum bid you can place** to keep your target margin.

🇵🇱 *Kalkulator importu aut z USA: lot z IAAI → pełny koszt sprowadzenia do Polski (opłaty aukcyjne, transport, cło, VAT, akcyza, naprawa) → porównanie z cenami z Otomoto → zysk i maksymalna kwota licytacji.*

### What it does

1. Searches IAAI for your keywords (e.g. `bmw x5`, `toyota rav4 hybrid`, `ford mustang`) with an optional model-year range.
2. Extracts each lot: year, make, model, masked VIN, damage, odometer (mi and km), Run & Drive status, engine, horsepower, fuel, branch, ACV, Buy Now price, auction date and photo.
3. Calculates the complete import cost to Poland:
   - IAAI buyer fee and bid fee (2026 non-licensed fee schedule) plus service and title fees
   - US inland transport estimated from the branch state to the nearest export port
   - ocean freight, insurance and broker fee
   - EU customs duty (10%) and import VAT for Bremerhaven (19%), Rotterdam (21%) or Gdynia (23%)
   - **Polish excise tax (akcyza)**: 3.1% / 18.6% by engine size, 1.55% / 9.3% for hybrids, exemptions for EVs and PHEVs up to 2.0 l
   - transport to Poland, registration paperwork and a damage-based repair estimate
4. Looks up comparable **undamaged** cars on **Otomoto.pl**: same model, year ±1, same fuel type and power ±15%, then computes median, quartiles and sample size.
5. Returns profit, ROI and the **maximum bid** for your target profit.

All exchange rates come from the official **NBP (National Bank of Poland)** daily table.

### Who is it for

- Car importers and brokers in Poland and the EU sourcing salvage cars from the USA
- Car flippers and body shops deciding which IAAI lots are worth bidding on
- Analysts tracking US-to-Europe price arbitrage
- Anyone who asks "ile kosztuje sprowadzenie auta z USA?" before bidding

### Input

| Field | Description |
|---|---|
| `searches` | IAAI keywords, one per line |
| `yearFrom` / `yearTo` | Model year range |
| `maxLotsPerSearch` | How many lots to analyze per search |
| `runAndDriveOnly` | Keep only Run & Drive cars |
| `onlyProfitable` | Output only lots with positive estimated profit |
| `targetProfitPln` | Profit you want to keep, used for the maximum bid |
| `assumedBidPctOfAcv` | Expected winning bid as % of ACV. Empty means typical values per damage type |
| `destinationPort` | Bremerhaven, Rotterdam or Gdynia |
| cost fields | Override freight, broker fee, port fees, duty, registration, repair multiplier |

Example:

```json
{
  "searches": ["bmw x5", "toyota camry"],
  "yearFrom": 2018,
  "maxLotsPerSearch": 50,
  "targetProfitPln": 8000,
  "destinationPort": "BREMERHAVEN"
}
```

### Output

Each dataset item is one IAAI lot with a full cost breakdown and market comparison:

```json
{
  "title": "2020 BMW X5 XDRIVE40I",
  "url": "https://www.iaai.com/VehicleDetail/...",
  "primaryDamage": "Front End",
  "odometerKm": 61200,
  "startCode": "Run & Drive",
  "engine": "3.0L I-6 DI, DOHC, VVT, turbo, 335HP",
  "acvUsd": 28594,
  "assumedBidUsd": 8575,
  "costs": {
    "auctionFeesUsd": 1105, "usInlandTransportUsd": 550, "oceanFreightUsd": 1150,
    "customsDutyPln": 4520, "importVatPln": 9400, "excisePln": 9340, "exciseRate": 0.186,
    "estimatedRepairPln": 24600, "totalLandedCostPln": 102033
  },
  "marketMedianPricePln": 169450,
  "estimatedProfitPln": 67417,
  "estimatedRoiPct": 66.1,
  "maxBidUsdForTargetProfit": 18525,
  "market": { "otomotoModel": "x5", "sampleSize": 24, "p25PricePln": 152000, "p75PricePln": 189000, "filtersUsed": "year ±1, fuel=petrol, power 285-385 HP, undamaged" }
}
```

The **Import profit overview** table view shows the key numbers side by side. Export to Excel, CSV, JSON or connect via API, Make, Zapier or n8n.

### Pricing

Pay per result: you pay only for analyzed lots. There is no start fee. A run with 100 lots costs a fraction of a dollar, and the market comparison is cached, so many lots of the same model do not slow the run down.

### Accuracy and limits

- Costs are **estimates** based on typical 2026 rates. Every cost component is configurable, so set your own broker, freight and repair numbers for precise results.
- IAAI shows current bids only to logged-in buyers, so the assumed bid is based on ACV or Buy Now. The **maximum bid** is the most useful number: it does not depend on the assumption.
- Repair estimates are a rough share of ACV by damage type. Always inspect photos.
- VINs are masked by IAAI for guests (last 6 characters hidden).
- Excise rules follow Polish law as of 2026 and are not tax advice.

### FAQ

**Is scraping IAAI and Otomoto legal?** The Actor reads only publicly available listing data, without logging in. You are responsible for using the data in line with the sites' terms and local law.

**Does it work for Copart?** Not yet. IAAI is supported now.

**Can I use it for other EU countries?** Yes for logistics and duty. Excise and the Otomoto comparison are Poland-specific. Set `destinationPort` and the cost fields to fit your case.

# Actor input Schema

## `searches` (type: `array`):

Keywords searched on IAAI, e.g. "bmw x5", "toyota rav4 hybrid", "ford mustang". Each search is processed separately.

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

Minimum model year.

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

Maximum model year.

## `maxLotsPerSearch` (type: `integer`):

How many IAAI lots to analyze per search.

## `runAndDriveOnly` (type: `boolean`):

Keep only lots marked Run & Drive.

## `skipZeroAcv` (type: `boolean`):

Skip lots where IAAI does not publish Actual Cash Value (needed for bid and repair estimates).

## `onlyProfitable` (type: `boolean`):

Output only lots where the estimated profit at the assumed bid is positive.

## `compareWithOtomoto` (type: `boolean`):

Look up undamaged comparable cars on Otomoto.pl (same model, year ±1, fuel, power ±15%) and compute market median, profit and maximum bid.

## `targetProfitPln` (type: `integer`):

Profit you want to keep per car. Used to compute the maximum bid.

## `assumedBidPctOfAcv` (type: `integer`):

Expected hammer price as % of IAAI ACV when no Buy Now price exists. Leave empty to use typical values by damage type (15% for flood/fire up to 55% for normal wear).

## `destinationPort` (type: `string`):

Where the car is cleared through customs. Sets the import VAT rate (DE 19%, NL 21%, PL 23%).

## `oceanFreightUsd` (type: `integer`):

Shared container shipping USA → EU port.

## `usInlandTransportUsd` (type: `integer`):

Leave empty to estimate from the IAAI branch state (to the nearest export port).

## `brokerFeeUsd` (type: `integer`):

Import broker / bidding account fee.

## `otherAuctionFeesUsd` (type: `integer`):

Service, title handling and environmental fees on top of the buyer and bid fee.

## `insurancePct` (type: `number`):

Cargo insurance as a percentage of the bid.

## `portAndClearanceEur` (type: `integer`):

Unloading, port fees and customs agency.

## `euTransportToPolandEur` (type: `integer`):

Truck transport from the EU port to Poland. Default 500 for DE/NL, 150 for Gdynia.

## `customsDutyPct` (type: `number`):

EU duty on passenger cars.

## `registrationPln` (type: `integer`):

Translations, technical inspection, registration.

## `repairCostFactor` (type: `number`):

Scales the damage-based repair estimate (1 = default, 0 = ignore repairs).

## `otomotoPagesPerQuery` (type: `integer`):

Result pages (32 ads each) used to compute market statistics.

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

Optional Apify Proxy.

## Actor input object example

```json
{
  "searches": [
    "bmw x5"
  ],
  "yearFrom": 2018,
  "maxLotsPerSearch": 20,
  "runAndDriveOnly": false,
  "skipZeroAcv": true,
  "onlyProfitable": false,
  "compareWithOtomoto": true,
  "targetProfitPln": 5000,
  "destinationPort": "BREMERHAVEN",
  "oceanFreightUsd": 1150,
  "brokerFeeUsd": 400,
  "otherAuctionFeesUsd": 140,
  "insurancePct": 1.5,
  "portAndClearanceEur": 500,
  "customsDutyPct": 10,
  "registrationPln": 1500,
  "repairCostFactor": 1,
  "otomotoPagesPerQuery": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

## `results` (type: `string`):

No description

# 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 = {
    "searches": [
        "bmw x5"
    ],
    "yearFrom": 2018,
    "maxLotsPerSearch": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("donzely/iaai-import-calculator-poland").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 = {
    "searches": ["bmw x5"],
    "yearFrom": 2018,
    "maxLotsPerSearch": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("donzely/iaai-import-calculator-poland").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searches": [
    "bmw x5"
  ],
  "yearFrom": 2018,
  "maxLotsPerSearch": 20
}' |
apify call donzely/iaai-import-calculator-poland --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,donzely/iaai-import-calculator-poland"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/d62gZENLAJO4CJ7lv/builds/5W1pLfZa6sJz2e603/openapi.json