# Autogidas.lt Car Ads Extractor (`steeriq/autogidas-scraper`) Actor

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

- **URL**: https://apify.com/steeriq/autogidas-scraper.md
- **Developed by:** [steeriq](https://apify.com/steeriq) (community)
- **Categories:** E-commerce, Integrations, Automation
- **Stats:** 1 total users, 1 monthly users, 86.7% 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

## Autogidas.lt Car Ads Extractor

Turns publicly listed used-car ads on [Autogidas.lt](https://autogidas.lt) into a
structured dataset — price, year, mileage, engine, gearbox, 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 Autogidas' 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. That includes `sellerName`, which is simply the dealer
or seller name the ad itself displays.

### Start URLs are the primary input

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

That is the intended way to run this actor. The site's own search 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://autogidas.lt/en/skelbimai/automobiliai/bmw/" }],
  "scrapeDetails": true,
  "maxItems": 1000
}
```

Lithuanian, Russian and Latvian URLs all work — they are rewritten to the
English edition before they are fetched, so the labels come back in English.

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

`makes`, `priceFrom/To`, `yearFrom/To`, `mileageFrom/To`, `fuelType`,
`bodyType`, `gearbox`, `city`, `validInspectionOnly`, `withVinOnly` and
`hideAuctions` exist for callers that have to construct input programmatically
and cannot obtain a URL. They rebuild an Autogidas search from scratch and reach
only a subset of what the site's search can express — everything else it offers,
such as "only cars in Lithuania", 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.

One thing to know if you do use them: Autogidas puts make and model in the URL
path, so each make/model combination becomes its own search and the actor runs
them all. The make dropdown is a suggestion rather than a whitelist — a make the
site's own picker omits can still be typed in — and models are free text,
because the site publishes no per-make model list.

### Settings that apply either way

| Field | What it does |
| --- | --- |
| `scrapeDetails` | Visit each ad for the full parameter set (description, defects, consumption figures, all photos). Turn it off for ~20x fewer requests and the results-page fields only. |
| `maxItems` | Hard cap on ads pushed to the dataset. |
| `proxyConfiguration` | Residential proxy pinned to Lithuania, by default. |

**Keep the Lithuania-pinned residential proxy.** Cloudflare fronts the site and
403s a share of foreign exit IPs. With the defaults left alone, a measured
platform run made 64 requests with zero failures and zero retries.

Unlike the sibling Autoplius actor there is **no pagination cap** — the full
\~28,000-ad catalogue is reachable from a single search.

### Output

One dataset record per ad. Known parameters are mapped to typed fields — `price`,
`year`, `mileageKm`, `powerKw`, `cylinders`, `gears`, `steeringSide`, `defects`,
`firstRegistrationCountry`, fuel consumption and `imageUrls` among them — 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.

Note that Autogidas **masks the VIN** (`WVWZZZAU...`), so the field is reported
as `vinPartial` rather than `vin`.

# Actor input Schema

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

The recommended input. Build the search on autogidas.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. Autogidas puts make and model in the URL path, so each combination becomes its own search. The make list is a suggestion, not a whitelist — it comes from the site's own make picker, so a make it omits can still be typed in. Models are free text: the site publishes no model list per make, and Apify input forms cannot drive one dropdown off another.

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

Earliest manufacture year.

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

Latest manufacture 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.

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

Any combination; leave empty for all.

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

Any combination; leave empty for all.

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

Autogidas allows only one gearbox value per search.

## `city` (type: `string`):

Lithuanian city as the site spells it, e.g. `Vilnius`, `Kaunas`, `Klaipėda`.

## `validInspectionOnly` (type: `boolean`):

Only ads with a valid technical inspection (Galiojanti TA).

## `withVinOnly` (type: `boolean`):

Only ads that publish a VIN code.

## `hideAuctions` (type: `boolean`):

Exclude ads that come from auctions.

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

Visit each ad for the full parameter set (colour, doors, euro standard, fuel consumption, weight, partial VIN, all photos). Uncheck for a much faster, shallower pass over the results pages only.

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

Stop after this many ads. Autogidas does not cap pagination, so a broad search can reach the full result set (~28,000 for all cars).

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

Kept low by default: the site sits behind Cloudflare.

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

How many times a blocked request is retried. Each retry draws a new proxy session and exit IP, which is how a working one is found. Short runs (a search matching only a few ads) rely on this most, because the session pool never warms up. Lowering it makes small searches fail outright.

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

Residential proxy pinned to Lithuania is strongly recommended. Autogidas 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://autogidas.lt/en/skelbimai/automobiliai/bmw/"
    }
  ],
  "validInspectionOnly": false,
  "withVinOnly": false,
  "hideAuctions": false,
  "scrapeDetails": true,
  "maxItems": 1000,
  "maxConcurrency": 5,
  "maxRequestRetries": 25,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "LT"
  }
}
```

# Actor output Schema

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

All publicly listed Autogidas.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://autogidas.lt/en/skelbimai/automobiliai/bmw/"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("steeriq/autogidas-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://autogidas.lt/en/skelbimai/automobiliai/bmw/" }] }

# Run the Actor and wait for it to finish
run = client.actor("steeriq/autogidas-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://autogidas.lt/en/skelbimai/automobiliai/bmw/"
    }
  ]
}' |
apify call steeriq/autogidas-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,steeriq/autogidas-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/eMjTupS2TMCEDH5Gb/builds/oR3xEf2KHt0EjePbC/openapi.json