# Arabam.com Scraper - Turkey Used Car Listings (`rastriq/arabam-scraper`) Actor

Scrape used car listings from arabam.com, one of Turkey's largest car marketplaces: price in TRY, make, model, year, mileage, city, district, dealer flag and photo. Same field names as the other Rastriq car scrapers. Turkish residential proxy pre-selected.

- **URL**: https://apify.com/rastriq/arabam-scraper.md
- **Developed by:** [Rastriq — Structured data from the world](https://apify.com/rastriq) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 listing returneds

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

## Arabam.com Scraper

**Arabam.com Scraper** extracts used car listings from arabam.com, one of Turkey's largest car marketplaces: price in Turkish lira (TRY), make, model, year, mileage, city, district, dealer flag, photo and the listing URL. Filter by make, model, fuel, price and year and export a clean, de-duplicated dataset to JSON, CSV or Excel; no browser, no login.

> Part of the Rastriq car-marketplace family: the core fields (`id`, `title`, `make`, `model`, `year`, `km`, `hp`, `price`, `currency`, `fuel_type`, `gearbox`, `city`, `region`, `is_professional`, `url`, `img_url`, `source`, `scraped_at`) are identical across countries, and source-specific extras are prefixed `ext_`. Datasets from several countries can be stacked without re-mapping.

### What data you get with Arabam.com Scraper

Arabam.com Scraper returns one flat record per listing. Fields the source does not provide are `null`; nothing is guessed.

| Field | Type | Description |
|---|---|---|
| `id` | string | arabam.com listing ID. |
| `title` | string (nullable) | Make and model line as shown in the results table (for example "Opel Astra 1.6 Comfort"). |
| `make` | string (nullable) | Car brand (from the site taxonomy). |
| `model` | string (nullable) | Car model. |
| `year` | integer (nullable) | Year of manufacture. |
| `km` | integer (nullable) | Mileage in kilometres. |
| `hp` | integer (nullable) | Not shown by the source: always null. |
| `price` | integer (nullable) | Asking price in whole TRY. |
| `currency` | string | ISO 4217 currency code, always TRY. |
| `fuel_type` | string (nullable) | Not shown by the source: always null. Use the fuel input as a filter instead. |
| `gearbox` | string (nullable) | Not shown by the source: always null. |
| `city` | string (nullable) | City (il). |
| `region` | string (nullable) | District (ilçe). |
| `is_professional` | boolean (nullable) | true when the ad comes from a dealer or authorised dealer (detected from the listing URL), false otherwise. |
| `url` | string (nullable) | Direct link to the listing on arabam.com. |
| `img_url` | string (nullable) | Main photo. |
| `source` | string | Always arabam.com. |
| `scraped_at` | string | UTC extraction timestamp, ISO 8601. |
| `ext_ad_title` | string (nullable) | Seller headline of the ad, in Turkish. |
| `ext_color` | string (nullable) | Colour as shown, in Turkish. |
| `ext_listing_date` | string (nullable) | Listing date as shown by the site, in Turkish (for example "24 Ekim 2026"). |

### How to use Arabam.com Scraper

1. Open **Arabam.com Scraper** on Apify and click **Try for free**.
2. Optionally enter a `make` (for example `renault`) and a `model` (for example `clio`), plus fuel, price and year filters.
3. Set **Max pages** (20 listings per page) and **Max items**. The prefill (1 page, 10 items) is a cheap first test.
4. Keep the default **Turkish residential proxy** and click **Start**.
5. Download the dataset from the **Output** tab as JSON, CSV or Excel, or read it through the API.

Typical uses of Arabam.com Scraper:

- Track used car prices in Turkey by make, model and year
- Separate dealer stock from private sellers with `is_professional`
- Compare the Turkish market with other countries using the same field names

### Input example

The prefilled input of Arabam.com Scraper (a cheap first run):

```json
{
  "maxPages": 1,
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "TR"
  }
}
```

| Parameter | Type | Default | Prefill | Description |
|---|---|---|---|---|
| `make` | string | any | — | Brand as in the arabam.com URL, lowercase. Examples: `renault`, `fiat`, `volkswagen`, `bmw`. Leave empty for all brands. |
| `model` | string | any | — | Model as in the URL, lowercase. Needs a make. Examples: `clio` (with `renault`), `egea` (with `fiat`). |
| `fuel` | string | any | — | Only return cars with this fuel type. It works as a filter only: arabam.com does not show the fuel in the results table, so the `fuel_type` output field stays null. |
| `minPrice` | integer | — | — | Lowest asking price in Turkish lira, for example `500000`. |
| `maxPrice` | integer | — | — | Highest asking price in Turkish lira, for example `1500000`. |
| `minYear` | integer | — | — | Oldest year of manufacture, for example `2018`. |
| `maxYear` | integer | — | — | Newest year of manufacture, for example `2024`. |
| `maxPages` | integer | `3` | `1` | Maximum number of result pages to read (20 listings per page). Use 1 for a quick test. |
| `maxItems` | integer | `50` | `10` | Maximum number of listings to return in total. Example: `10` costs about $0.035. |
| `proxyConfiguration` | object | Residential TR | Residential TR | Residential proxy from Turkey is required: arabam.com answers HTTP 403 to datacenter IPs, so the default is Apify RESIDENTIAL with country `TR`. The Turkish residential proxy is included in the price: you only pay the events listed in Pricing. If a run is blocked it fails with a clear message. |

### Output example

A real record returned by Arabam.com Scraper:

```json
{
  "id": "45056104",
  "title": "Opel Astra 1.6 Comfort",
  "make": "Opel",
  "model": "Astra",
  "year": 2003,
  "km": 205000,
  "hp": null,
  "price": 515000,
  "currency": "TRY",
  "fuel_type": null,
  "gearbox": null,
  "city": "Uşak",
  "region": "Merkez",
  "is_professional": true,
  "url": "https://www.arabam.com/ilan/galeriden-satilik-opel-astra-1-6-comfort/10-yillik-sahibinden-hatasiz-bebek-astra/45056104",
  "img_url": "https://arbstorage.mncdn.com/ilanfotograflari/2026/10/24/45056104/2e801ffe-76c1-4b46-876e-de778f262acf_image_for_silan_45056104_1920x1080.jpg",
  "source": "arabam.com",
  "scraped_at": "2026-10-24T20:54:21.579996+00:00",
  "ext_ad_title": "10 YILLIK SAHİBİNDEN HATASIZ BEBEK ASTRA",
  "ext_color": "Kırmızı",
  "ext_listing_date": "24 Ekim 2026"
}
```

### Pricing

Arabam.com Scraper uses pay-per-event pricing: **$0.005 per run start** plus **$0.003 per listing** ($3.00 per 1,000). You only pay for unique listings delivered to the dataset; a run that returns nothing charges no listings.

| Run | Cost in events |
|---|---|
| 10 listings (prefill) | $0.035 |
| 50 listings (default run) | $0.155 |
| 1,000 listings | $3.005 |
| 10,000 listings | $30.005 |

Arabam.com blocks datacenter IPs, so Arabam.com Scraper uses Apify **Residential proxy (Turkey)** by default. The proxy is included in the price: you only pay the events listed above, with no extra proxy or platform charges.

Tip: start with the prefilled input, check the output, then raise `maxPages` and `maxItems`.

### Limitations

- **Not shown by the source:** `hp`, `fuel_type` and `gearbox` are always `null`, because the arabam.com results table does not show them. You can still filter by fuel with the `fuel` input.
- `is_professional` is detected from the listing URL (`galeriden` = dealer, `yetkili` = authorised dealer); treat it as a good indicator, not an official seller type.
- arabam.com does not publish a total result counter, so the Actor cannot tell you in advance how many listings match. Pagination was tested over 10 pages: 200 unique listings, no duplicates.
- Prices are asking prices in TRY and can contain placeholder values set by sellers; they are reported as shown and never filtered.
- `ext_ad_title`, `ext_color` and `ext_listing_date` are returned in Turkish, as shown by the site.
- If arabam.com answers HTTP 403/429 and nothing could be read, the run fails with a clear message instead of returning an empty dataset.

### Related Actors

Other Rastriq car-marketplace scrapers with the same core fields:

| Country | Actor | Notes |
|---|---|---|
| Portugal | [StandVirtual Scraper](https://apify.com/rastriq/standvirtual-scraper) | dealer-heavy marketplace |
| Portugal | [CustoJusto Scraper](https://apify.com/rastriq/custojusto-scraper) | general classifieds, many private sellers |
| Switzerland | [Comparis.ch Scraper](https://apify.com/rastriq/comparis-scraper) | with comparis market price |
| Poland | [OtoMoto Scraper](https://apify.com/rastriq/otomoto-scraper) | largest Polish marketplace |
| Romania | [Autovit Scraper](https://apify.com/rastriq/autovit-scraper) | Romanian marketplace |
| Spain | [Coches.net Scraper](https://apify.com/rastriq/cochesnet-spain) | Spain's top marketplace |
| Turkey | [Sahibinden Scraper](https://apify.com/rastriq/sahibinden-scraper) | Turkey's other big marketplace |

### FAQ

**Is it legal to scrape arabam.com?** Arabam.com Scraper reads publicly visible listing pages at a low request rate, without logging in or bypassing access controls, and it does not extract seller names or phone numbers. Check the website terms and make sure your use of the data complies with the law that applies to you, including data protection rules.

**Does Arabam.com Scraper need a proxy?** Yes. arabam.com returns HTTP 403 to datacenter IPs, so a Turkish residential proxy is pre-selected (Apify Proxy, group RESIDENTIAL, country `TR`). It is included in the price: you only pay the events listed in Pricing. Do not switch to datacenter proxies.

**How often should I run Arabam.com Scraper?** Listings change daily. Weekly runs by make and model are a good balance for price tracking; split large markets with make, model, price and year filters.

**Can I schedule Arabam.com Scraper or call it from my code?** Yes. Use Apify schedules, the API, or integrations such as Make, Zapier or Google Sheets to run it automatically and send the dataset on.

**Something broke or a field is missing?** arabam.com changes its pages from time to time. Open an issue on the Actor page and include the run link.

# Actor input Schema

## `make` (type: `string`):

Brand as in the arabam.com URL, lowercase. Examples: <code>renault</code>, <code>fiat</code>, <code>volkswagen</code>, <code>bmw</code>. Leave empty for all brands.

## `model` (type: `string`):

Model as in the URL, lowercase. Needs a make. Examples: <code>clio</code> (with <code>renault</code>), <code>egea</code> (with <code>fiat</code>).

## `fuel` (type: `string`):

Only return cars with this fuel type. It works as a filter only: arabam.com does not show the fuel in the results table, so the <code>fuel_type</code> output field stays null.

## `minPrice` (type: `integer`):

Lowest asking price in Turkish lira, for example <code>500000</code>.

## `maxPrice` (type: `integer`):

Highest asking price in Turkish lira, for example <code>1500000</code>.

## `minYear` (type: `integer`):

Oldest year of manufacture, for example <code>2018</code>.

## `maxYear` (type: `integer`):

Newest year of manufacture, for example <code>2024</code>.

## `maxPages` (type: `integer`):

Maximum number of result pages to read (20 listings per page). Use 1 for a quick test.

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

Maximum number of listings to return in total. Example: <code>10</code> costs about $0.035.

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

<b>Residential proxy from Turkey is required</b>: arabam.com answers HTTP 403 to datacenter IPs, so the default is Apify RESIDENTIAL with country <code>TR</code>. The Turkish residential proxy is included in the price: you only pay the events listed in the Pricing tab. If a run is blocked it fails with a clear message.

## Actor input object example

```json
{
  "make": "",
  "model": "",
  "fuel": "",
  "maxPages": 1,
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "TR"
  }
}
```

# Actor output Schema

## `listings` (type: `string`):

Used car listings extracted from arabam.com.

# 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 = {
    "maxPages": 1,
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "TR"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rastriq/arabam-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 = {
    "maxPages": 1,
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "TR",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("rastriq/arabam-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 '{
  "maxPages": 1,
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "TR"
  }
}' |
apify call rastriq/arabam-scraper --silent --output-dataset

```

## MCP server setup

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