# Arabam.com Scraper | Fast & Reliable (`fatihtahta/arabam-com-scraper`) Actor

Scrape live vehicle listings from Arabam.com including prices, specs, sellers and more.. Ideal for market research, price tracking, or inventory monitoring. Fast, structured, reliable.

- **URL**: https://apify.com/fatihtahta/arabam-com-scraper.md
- **Developed by:** [Fatih Tahta](https://apify.com/fatihtahta) (community)
- **Categories:** E-commerce, Developer tools, Automation
- **Stats:** 65 total users, 11 monthly users, 100.0% runs succeeded, 4 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.00 / 1,000 vehicle listings

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

**Slug:** `fatihtahta/arabam-com-scraper`

### Overview

Arabam.com Scraper collects structured vehicle listing data from Arabam.com, including listing identifiers, URLs, titles, descriptions, pricing, vehicle attributes, media, source context, and list-page summary fields. [Arabam.com](https://www.arabam.com) is a major automotive marketplace in Turkey, making its public listing data useful for pricing analysis, inventory monitoring, market research, and operational reporting. The actor converts public listing pages and category/search URLs into repeatable JSON records that can be used in analytics, enrichment, and monitoring workflows. It is designed for recurring data acquisition where consistent structure, automation readiness, and predictable exports matter. Results reflect the publicly available data at the time of each run, without making assumptions about future availability or completeness.

### Why Use This Actor

- **Market research and analytics teams:** build market intelligence datasets for vehicle supply, pricing, mileage, model-year distribution, and category movement.
- **Product and content teams:** normalize listing attributes for catalog analysis, editorial research, comparison experiences, or internal content workflows.
- **Developers and data engineering teams:** feed structured extraction results into downstream systems, warehouses, APIs, and recurring ETL pipelines.
- **Lead generation and enrichment teams:** enrich existing CRM or prospecting datasets with current public vehicle listing attributes and source URLs.
- **Monitoring and competitive tracking teams:** schedule repeatable collection for operational reporting, price movement checks, and inventory availability monitoring.

### Common Use Cases

- **Market intelligence:** monitor vehicle supply, prices, model years, mileage ranges, fuel types, transmissions, and category movement.
- **Inventory tracking:** follow public listings for specific brands, models, or category URLs over time.
- **Competitive monitoring:** compare asking prices, listing titles, availability, and vehicle attributes across marketplace segments.
- **Catalog and directory building:** populate internal databases with structured public vehicle listing records.
- **Data enrichment:** add current public listing URLs, prices, media, and vehicle attributes to CRM, BI, or analytics datasets.
- **Recurring reporting:** schedule periodic runs for dashboards, alerts, historical trend analysis, and operational reporting.

### Quick Start

1. Choose one or more Arabam.com search, category, or listing detail URLs for the vehicle segment you want to collect.
2. Set a small `limit` for your first validation run, such as `10` or `25`.
3. Run the actor in Apify Console.
4. Inspect the first dataset records to confirm the output fields match your workflow.
5. Increase `limit`, add more URLs, or schedule the actor once the output is verified.

### Input Parameters

The actor accepts Arabam.com URLs and a maximum listing count. Connection handling is managed internally for reliability.

| Parameter | Type | Description | Default |
| --- | --- | --- | --- |
| `startUrls` | array of strings | One or more Arabam.com search, category, or listing detail URLs to collect from. Use URLs that already represent the scope you want, such as a search query, category page, or individual listing. | `["https://www.arabam.com/ikinci-el/otomobil"]` |
| `limit` | integer | Maximum number of listings to save across the whole run. Minimum value: `10`. | `50000` |

### Choosing Inputs

Use `startUrls` when you already know the Arabam.com search, category, or detail page you want to collect. Broader category URLs are useful for discovery, while more specific search or category URLs produce more targeted datasets. Because the actor uses the URLs you provide, choose URLs that already contain the desired search text, category, or other public filters available on Arabam.com. Start with a small `limit` to validate record shape and coverage, then increase it for larger collection or scheduled monitoring.

### Example Inputs

#### Scenario: Query-driven search

```json
{
  "startUrls": [
    "https://www.arabam.com/ikinci-el?searchText=volkswagen"
  ],
  "limit": 25
}
```

#### Scenario: Category monitoring

```json
{
  "startUrls": [
    "https://www.arabam.com/ikinci-el/otomobil/audi"
  ],
  "limit": 50
}
```

#### Scenario: Direct listing validation

```json
{
  "startUrls": [
    "https://www.arabam.com/ilan/galeriden-satilik-audi-a3-sedan-35-tfsi-advanced/hatasiz-boyasiz-audi-a3-premio-comfort/40770073"
  ],
  "limit": 10
}
```

### Output

#### 9.1 Output destination

The actor writes results to an Apify dataset as JSON records. The dataset is designed for direct consumption by analytics tools, ETL pipelines, and downstream APIs with minimal post-processing.

When multiple entity types or record shapes exist, the README documents each shape separately based on the provided Example Output. The provided output contains one vehicle listing record shape.

#### 9.2 Record envelope and stable identifiers

Each record represents one Arabam.com vehicle listing. The recommended idempotency key is `listing_id`, with `url` and `source_context.canonical_url` available as secondary stable identifiers when syncing records across repeated runs. Use this key to deduplicate records or upsert existing rows in warehouses, CRMs, search indexes, and internal databases. Stable identifiers make records easier to merge, deduplicate, and sync across repeated runs.

The `source_context` object records public source information for the listing, including the source URL, loaded URL, list page URL, canonical URL, page type, domain, and scrape timestamp.

#### 9.3 Examples

Example: vehicle listing

```json
{
  "listing_id": "40770073",
  "url": "https://www.arabam.com/ilan/galeriden-satilik-audi-a3-sedan-35-tfsi-advanced/hatasiz-boyasiz-audi-a3-premio-comfort/40770073",
  "title": "HATASIZ BOYASIZ AUDİ A3 PREMİO COMFORT",
  "description": "HATASIZ BOYASIZ AUDİ A3 PREMİO COMFORT",
  "source_context": {
    "source_url": "https://www.arabam.com/ilan/galeriden-satilik-audi-a3-sedan-35-tfsi-advanced/hatasiz-boyasiz-audi-a3-premio-comfort/40770073",
    "loaded_url": "https://www.arabam.com/ilan/galeriden-satilik-audi-a3-sedan-35-tfsi-advanced/hatasiz-boyasiz-audi-a3-premio-comfort/40770073",
    "list_page_url": "https://www.arabam.com/ikinci-el/otomobil/audi?take=50",
    "canonical_url": "https://www.arabam.com/ilan/galeriden-satilik-audi-a3-sedan-35-tfsi-advanced/hatasiz-boyasiz-audi-a3-premio-comfort/40770073",
    "page_type": "LIST",
    "domain": "www.arabam.com",
    "scraped_at": "2026-05-26T21:12:39.584Z"
  },
  "pricing": {
    "amount": 40000,
    "currency": "TRY",
    "availability": "InStock",
    "offer_url": "https://www.arabam.com/ilan/galeriden-satilik-audi-a3-sedan-35-tfsi-advanced/hatasiz-boyasiz-audi-a3-premio-comfort/40770073"
  },
  "vehicle": {
    "make": "Audi",
    "manufacturer": "Audi",
    "year": 2023,
    "year_text": "2023",
    "production_year": 2023,
    "production_year_text": "2023",
    "condition": "UsedCondition",
    "mileage": {
      "value": 40000,
      "unit": "km",
      "text": "40000"
    },
    "fuel_type": "Benzin",
    "transmission": "Otomatik",
    "drivetrain": "Önden Çekiş"
  },
  "location": {
    "display_text": "2.537.500 TL"
  },
  "media": {
    "images": [
      "https://arbstorage.mncdn.com/ilanfotograflari/2026/05/25/40770073/3be81aaa-c76e-440e-9835-e43b29e5ee41_image_for_silan_40770073_120x90.jpg"
    ]
  },
  "list_summary": {
    "model_name": "Audi A3 Sedan 35 TFSI Advanced",
    "title": "HATASIZ BOYASIZ AUDİ A3 PREMİO COMFORT"
  }
}
```

### Field Reference

#### Vehicle listing

**listing_id** *(string, required)*: Stable Arabam.com listing identifier.

**url** *(string, required)*: Public listing URL.

**title** *(string, optional)*: Listing title.

**description** *(string, optional)*: Listing description or short description text.

**source_context.source_url** *(string, optional)*: URL used as the source for the record.

**source_context.loaded_url** *(string, optional)*: Final public URL associated with the loaded record.

**source_context.list_page_url** *(string, optional)*: Search or category URL where the listing was discovered, when available.

**source_context.canonical_url** *(string, optional)*: Canonical public URL for the listing.

**source_context.page_type** *(string, optional)*: Source page classification included with the record.

**source_context.domain** *(string, optional)*: Source domain.

**source_context.scraped_at** *(string, optional)*: ISO 8601 timestamp for when the record was collected.

**pricing.amount** *(number, optional)*: Numeric price amount when available.

**pricing.currency** *(string, optional)*: Price currency, such as `TRY`.

**pricing.availability** *(string, optional)*: Listing availability value when provided.

**pricing.offer_url** *(string, optional)*: Public offer or listing URL associated with the price.

**vehicle.make / vehicle.manufacturer** *(string, optional)*: Vehicle make and manufacturer values.

**vehicle.year / vehicle.year_text** *(number/string, optional)*: Model year as numeric and text values.

**vehicle.production_year / vehicle.production_year_text** *(number/string, optional)*: Production year as numeric and text values.

**vehicle.condition** *(string, optional)*: Vehicle condition value.

**vehicle.mileage.value** *(number, optional)*: Mileage value.

**vehicle.mileage.unit** *(string, optional)*: Mileage unit, such as `km`.

**vehicle.mileage.text** *(string, optional)*: Mileage as displayed in source data.

**vehicle.fuel_type** *(string, optional)*: Fuel type.

**vehicle.transmission** *(string, optional)*: Transmission type.

**vehicle.drivetrain** *(string, optional)*: Drivetrain value.

**location.display_text** *(string, optional)*: Location or display text associated with the listing.

**media.images** *(array of strings, optional)*: Public image URLs for the listing.

**list_summary.model_name** *(string, optional)*: Model name from the list summary.

**list_summary.title** *(string, optional)*: Listing title from the list summary.

### Data Quality, Guarantees, And Handling

- **Structured records:** results are normalized into predictable JSON objects for downstream use.
- **Best-effort extraction:** fields may vary by region, session, availability, and UI experiments.
- **Optional fields:** null-check optional values in downstream code, especially listing details, media, location text, and vehicle attributes.
- **Deduplication:** use `listing_id` as the primary stable key, with `url` or `source_context.canonical_url` as secondary comparison fields.
- **Freshness:** results reflect the publicly available data at run time.
- **Repeated runs:** use the recommended idempotency key when syncing data into warehouses, CRMs, or search indexes.

### Tips For Best Results

- Start with a small `limit` to validate the output shape before scaling up.
- Use one search or category URL per run when you need cleaner segmentation.
- Use broader category URLs when the goal is discovery.
- Use more specific search or category URLs when you need targeted records.
- Increase `limit` only after confirming that the first records match your use case.
- Schedule recurring runs for monitoring workflows instead of relying on manual one-off collection.
- Use `listing_id` for deduplication when storing results over time.

### How to Run on Apify

1. Open the Actor in Apify Console.
2. Configure the available input fields for the target scope.
3. Set the maximum number of outputs to collect.
4. Click **Start** and wait for the run to finish.
5. Download results in JSON, CSV, Excel, or other supported formats.

### Scheduling & Automation

#### Scheduling

**Automated Data Collection**

Schedule recurring runs to keep Arabam.com listing datasets fresh for monitoring, reporting, and enrichment workflows. Choose a cadence that matches how often your downstream systems need updated vehicle listing data.

- Navigate to **Schedules** in Apify Console
- Create a new schedule, such as daily, weekly, or custom cron
- Configure input parameters
- Enable notifications for run completion
- Add webhooks for automated processing

#### Integration Options

- **BI dashboards:** monitor vehicle prices, availability, mileage bands, model-year distribution, and category movement over time.
- **Data warehouses:** store recurring listing snapshots for historical analysis and operational reporting.
- **CRM enrichment:** sync public vehicle listing attributes and source URLs into lead, account, or inventory records.
- **Webhooks:** trigger validation, notification, or ingestion workflows after each completed run.
- **Google Sheets or Airtable:** review smaller listing samples, category checks, and market research exports with non-technical teams.
- **Alerts:** notify teams when monitored segments return new, changed, or newly unavailable listings.

### Export Formats And Downstream Use

Apify datasets can be exported or consumed by downstream systems for analysis, review, and automated ingestion.

- **JSON:** for APIs, applications, and data pipelines
- **CSV or Excel:** for spreadsheet workflows and manual review
- **API access:** for automated ingestion into internal systems
- **BI and warehouses:** for reporting, dashboards, and historical analysis

### Performance

Estimated run times:

- **Small runs (< 1,000 outputs):** ~3-5 minutes
- **Medium runs (1,000-5,000 outputs):** ~5-15 minutes
- **Large runs (5,000+ outputs):** ~15-30 minutes

Execution time varies based on filters, result volume, and how much information is returned per record. Highly filtered runs can finish faster, while broad discovery or detail-rich records may take longer.

### Limitations

- Availability depends on what [Arabam.com](https://www.arabam.com) publicly exposes at run time.
- Some optional fields may be missing on sparse records or certain listing types.
- Very broad searches may take longer or require higher limits.
- Target-side changes can affect field availability, naming, or formatting.
- Regional, account, or availability differences may change visible results.
- Results represent public listing data at collection time and may change after the run finishes.

### Troubleshooting

- **No results returned:** check the supplied URLs, confirm they are public Arabam.com search, category, or listing URLs, and verify that matching public records exist.
- **Fewer results than expected:** broaden the source URL scope, raise `limit`, or verify that the target segment contains enough matching records.
- **Some fields are empty:** optional fields depend on what each listing publicly provides.
- **Run takes longer than expected:** reduce scope, lower `limit` for validation, or split broad collection into smaller category or search segments.
- **Output changed:** compare the current output with the field reference and report a small sample if support is needed.

### FAQ

#### What data does this actor collect?

It collects public Arabam.com vehicle listing data, including listing identifiers, URLs, titles, descriptions, pricing, vehicle attributes, media, source context, and list summary fields when available.

#### Can I filter by location, category, date, price, or other criteria?

The input schema supports `startUrls`, so use Arabam.com URLs that already contain the search, category, or public filters you want to collect. The actor does not expose separate location, date, price, or sort fields in its input form.

#### Why did I receive fewer results than my limit?

The `limit` is a maximum, not a guarantee. A run may return fewer records if the supplied URLs contain fewer matching public listings, listings are unavailable, or optional source data is limited at run time.

#### Can I schedule recurring runs?

Yes. Use Apify schedules to run the actor daily, weekly, or on a custom cron cadence for monitoring and reporting workflows.

#### How do I avoid duplicates across runs?

Use `listing_id` as the primary deduplication and upsert key. You can also compare `url` or `source_context.canonical_url` when reconciling records across repeated runs.

#### Can I export the data to CSV, Excel, or JSON?

Yes. Apify datasets support exports in JSON, CSV, Excel, and other common formats.

#### Does this actor collect private data?

This actor is intended to collect publicly available listing information from Arabam.com. Users are responsible for using the data lawfully and respecting privacy, applicable regulations, and the target site's terms.

#### What should I include when reporting an issue?

Include the input used with sensitive values redacted, the run ID, expected versus actual behavior, and a small output sample when it helps explain the issue.

### Compliance & Ethics

#### Responsible Data Collection

This actor collects publicly available vehicle listing information from **https://www.arabam.com** for legitimate business purposes, including:

- **Automotive** research and market analysis
- Inventory monitoring and pricing intelligence
- Data enrichment for operational reporting and analytics

Users are responsible for ensuring that their use of collected data complies with applicable laws, regulations, and the target site's terms. This section is informational and not legal advice.

#### Best Practices

- Use collected data in accordance with applicable laws, regulations, and the target site's terms
- Respect individual privacy and personal information
- Use data responsibly and avoid disruptive or excessive collection
- Do not use this actor for spamming, harassment, or other harmful purposes
- Follow relevant data protection requirements where applicable, such as GDPR or CCPA

### Support

For help, open an issue on the actor page. Include the input used with sensitive values redacted, the run ID, expected versus actual behavior, and a small output sample if it helps clarify the problem. Avoid sharing secrets, credentials, or private data in support requests.

# Actor input Schema

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

Paste one or more Arabam.com search, category, or listing detail URLs.

## `limit` (type: `integer`):

Stop the run after this many listings have been saved in total.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.arabam.com/ikinci-el?searchText=volkswagen"
  ],
  "limit": 50000
}
```

# Actor output Schema

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

Structured Arabam.com vehicle listing records saved by this run.

# 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": [
        "https://www.arabam.com/ikinci-el?searchText=volkswagen"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fatihtahta/arabam-com-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": ["https://www.arabam.com/ikinci-el?searchText=volkswagen"] }

# Run the Actor and wait for it to finish
run = client.actor("fatihtahta/arabam-com-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": [
    "https://www.arabam.com/ikinci-el?searchText=volkswagen"
  ]
}' |
apify call fatihtahta/arabam-com-scraper --silent --output-dataset

```

## MCP server setup

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