# Autoplius.lt Car Ads Extractor (`steeriq/autoplius-scraper`) Actor

Extracts publicly available used-car listings from Autoplius.lt. Paste a search URL from the site and every matching public ad comes back as structured data — price, year, mileage, VIN, photos and the full parameter table. Only data any visitor can see on the site is returned.

- **URL**: https://apify.com/steeriq/autoplius-scraper.md
- **Developed by:** [steeriq](https://apify.com/steeriq) (community)
- **Categories:** Automation, Developer tools, E-commerce
- **Stats:** 1 total users, 1 monthly users, 73.3% runs succeeded, 0 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/actors/running/actors-in-store.md#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

## Autoplius.lt Car Ads Extractor

Turns publicly listed used-car ads on [Autoplius.lt](https://autoplius.lt) into a
structured dataset — price, year, mileage, engine, gearbox, VIN, photos and the
full parameter table from each ad.

**Only publicly available data is returned.** Everything this actor collects is
what any visitor sees on Autoplius' own public listing and ad pages. It signs in
to nothing, holds no account, and reaches nothing behind a login, a paywall or a
private area of the site.

### Start URLs are the primary input

**Build the search on autoplius.lt, then paste the URL into Start URLs.**

That is the intended way to run this actor. The site's own search box supports
far more than the filter fields below it — equipment, seller type, damage
status, colour, and every combination of them — and pasting the URL gets all of
it for free, exactly as the site interprets it. What you see in the browser is
what the dataset will contain.

Several URLs are fine. Their results are merged and de-duplicated, so two
overlapping searches never produce the same ad twice.

```jsonc
{
  "startUrls": [
    { "url": "https://en.autoplius.lt/ads/used-cars?category_id=2&make_id[97]=&make_id_list=97" }
  ],
  "scrapeDetails": true,
  "maxItems": 1000
}
```

Both `autoplius.lt` and `en.autoplius.lt` URLs work — a Lithuanian URL is
rewritten to the English site before it is fetched, so the labels and values
always come back in English.

### The filter fields are a fallback, and not recommended

`makes`, `priceFrom/To`, `yearFrom/To`, `mileageFrom/To`, `powerFrom/To`,
`fuelType`, `bodyType` and `gearbox` exist for callers that have to construct
input programmatically and cannot obtain a URL. They rebuild an Autoplius
search from scratch and reach only a subset of what the site's search can
express — everything else the site offers, such as "only cars in Lithuania" or
"exclude USA", is reachable only by pasting a URL.

**They are used only when Start URLs is empty.** Set a start URL and every
filter is discarded — no error, because there is nothing wrong with the input;
the run logs a warning naming each field it ignored. Apify input forms cannot
disable one field because another is filled, so this is the clearest signal the
platform allows.

Two further limits worth knowing before you rely on them:

- **Make names must be exact.** A name the actor cannot resolve to Autoplius'
  numeric id fails the run outright, so the dropdown is a closed list.
- **Model ids are site-internal and per-make.** There is no name lookup — you
  have to open the search on autoplius.lt and copy the `make_id[<id>]=` values
  out of the URL. At which point you already have the URL, which is the better
  input.

### Settings that apply either way

| Field | What it does |
| --- | --- |
| `scrapeDetails` | Visit each ad for the full parameter set (VIN, CO₂, euro standard, inspection date, description, all photos). Turn it off for ~20x fewer requests and the results-page fields only. |
| `transport` | `auto` (default) uses cheap HTTP and falls back to a browser only for requests Cloudflare blocks. `browser` is ~12x the cost for identical output. |
| `maxItems` | Hard cap on ads pushed to the dataset. |
| `proxyConfiguration` | Residential proxy pinned to Lithuania, by default. See below. |

**A Lithuania-pinned residential proxy is not optional.** Autoplius is behind
Cloudflare and 403s most foreign and datacenter exit IPs — an unpinned run was
blocked on every attempt, while an LT-pinned run got through. The default is
already correct; changing it is what breaks runs.

**One search returns at most ~5,500 ads (275 pages).** Past page 275 the site
re-serves the last real page instead of an empty one. The catalogue is ~42,000
ads, so to reach more of it, slice the search by make, price band or year and
pass several start URLs.

### Output

One dataset record per ad. Known parameters are mapped to typed fields — `price`,
`year`, `mileageKm`, `powerKw`, `vin`, `co2Gkm`, `euroStandard`,
`technicalInspectionUntil`, `imageUrls` and more — and **every** label/value row
from the ad is also kept verbatim in `rawParameters`, so a change on the site
adds unmapped keys rather than silently dropping data.

# Actor input Schema

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

The recommended input. Build the search on autoplius.lt using the site's own filters — including the many this actor does not expose — and paste the resulting URL here. Several URLs are fine; their results are merged and de-duplicated. Whenever this field is non-empty the filter fields below are ignored completely.

## `makes` (type: `array`):

One row per make, optionally narrowed to models. The make list is exhaustive: Autoplius addresses makes by numeric id, so a name the actor cannot resolve fails the run outright. Model ids are site-internal and per-make — build the search on autoplius.lt and copy the `make_id[..]=` values out of the URL. They cannot be a dropdown: Apify input forms cannot drive one dropdown off another.

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

Earliest first-registration year.

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

Latest first-registration year.

## `priceFrom` (type: `integer`):

Minimum asking price in EUR.

## `priceTo` (type: `integer`):

Maximum asking price in EUR.

## `mileageFrom` (type: `integer`):

Minimum odometer reading in kilometres.

## `mileageTo` (type: `integer`):

Maximum odometer reading in kilometres.

## `powerFrom` (type: `integer`):

Minimum engine power in kilowatts.

## `powerTo` (type: `integer`):

Maximum engine power in kilowatts.

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

Any combination; leave empty for all.

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

Any combination; leave empty for all.

## `gearbox` (type: `string`):

Autoplius allows only one gearbox value per search.

## `scrapeDetails` (type: `boolean`):

Visit each ad for the full parameter set (VIN, CO₂, euro standard, inspection date, description, all photos). Uncheck for a much faster, shallower pass over the results pages only.

## `transport` (type: `string`):

How pages are fetched. 'auto' (recommended) uses cheap HTTP and falls back to a browser only for requests Cloudflare blocks — same cost as HTTP when nothing is blocked. 'http' is cheapest but fails outright when challenged. 'browser' always renders in Chromium: reliable, but roughly 15x the cost and 7x the latency per request.

## `maxItems` (type: `integer`):

Stop after this many ads. Note: a single Autoplius search returns at most ~5,500 ads (275 pages) regardless — narrow the filters to reach more of the catalogue.

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

Kept low by default: the site is behind Cloudflare and aggressive concurrency triggers challenges.

## `maxRequestRetries` (type: `integer`):

How many times a blocked request is retried before it is handed to the browser fallback. Retries cost wall-clock, and wall-clock is compute cost, so this stays low in 'auto' mode.

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

Residential proxy pinned to Lithuania is strongly recommended. Autoplius is behind Cloudflare and 403s many foreign/datacenter exit IPs; an unpinned run was blocked on every attempt while an LT-pinned run got through.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://en.autoplius.lt/ads/used-cars?category_id=2&make_id[97]=&make_id_list=97"
    }
  ],
  "scrapeDetails": true,
  "transport": "auto",
  "maxItems": 1000,
  "maxConcurrency": 5,
  "maxRequestRetries": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "LT"
  }
}
```

# Actor output Schema

## `ads` (type: `string`):

All publicly listed Autoplius.lt car ads collected by this run, as JSON.

## `adsInConsole` (type: `string`):

Browse the extracted ads in Apify Console.

# 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": [
        {
            "url": "https://en.autoplius.lt/ads/used-cars?category_id=2&make_id[97]=&make_id_list=97"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("steeriq/autoplius-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": [{ "url": "https://en.autoplius.lt/ads/used-cars?category_id=2&make_id[97]=&make_id_list=97" }] }

# Run the Actor and wait for it to finish
run = client.actor("steeriq/autoplius-scraper").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 '{
  "startUrls": [
    {
      "url": "https://en.autoplius.lt/ads/used-cars?category_id=2&make_id[97]=&make_id_list=97"
    }
  ]
}' |
apify call steeriq/autoplius-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,steeriq/autoplius-scraper"
        }
    }
}

```

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/iLdRyjwfmrZ9g1bSM/builds/molx8EUc5BoI1rgHJ/openapi.json