Arabam.com Parser Quick Start Guide - Get Started in Minutes

Get started with Arabam.com parser in minutes. Extract Turkish automotive data with just a few lines of code.

What You'll Learn

• Set up authentication with your API key in minutes
• Make your first API call to extract Turkish vehicle data
• Understand response formats and data structure
• Build common use cases for market analysis
• Handle errors and optimize your requests

Prerequisites

Before you begin, ensure you have the basic requirements for successful integration.

System Requirements

Requirement	Minimum	Recommended
API Key	Valid Carapis key	Arabam.com parser access
Programming	Any language	JavaScript, Python, cURL
Network	Stable internet	High-speed connection
Knowledge	Basic API concepts	Turkish automotive market

Step 1: Get Your API Key

Getting Started

1. Sign up at Carapis Dashboard
2. Navigate to the API Keys section
3. Create a new API key for Arabam.com parser
4. Copy your API key (keep it secure!)
5. Start extracting Turkish automotive data

API Key Format

Your API key will look like this:

arabam_parser_sk_1234567890abcdef1234567890abcdef

Key components:

• arabam_parser_sk_ - Prefix identifying the parser
• 1234567890abcdef1234567890abcdef - 32-character unique identifier

Step 2: Install SDK (Optional)

JavaScript/Node.js

npm install @carapis/arabam-parser
# or
yarn add @carapis/arabam-parser

Python

pip install carapis-arabam-parser

PHP

composer require carapis/arabam-parser

SDK Benefits

• Pre-built functions for common operations
• Automatic error handling and retry logic
• Type safety and IntelliSense support
• Built-in validation for request parameters
• Simplified authentication and session management

Step 3: Make Your First Request

JavaScript Example

// Using the SDK
const { ArabamParser } = require('@carapis/arabam-parser');

const parser = new ArabamParser({
  apiKey: 'arabam_parser_sk_1234567890abcdef1234567890abcdef',
  region: 'istanbul',
});

// Extract vehicle listings
async function getVehicles() {
  try {
    const vehicles = await parser.extractListings({
      filters: {
        make: 'BMW',
        yearFrom: 2020,
        priceMax: 1000000,
      },
      limit: 10,
    });

    console.log(`Found ${vehicles.length} BMW vehicles`);
    vehicles.forEach((vehicle) => {
      console.log(`${vehicle.year} ${vehicle.make} ${vehicle.model} - ${vehicle.price.current} TL`);
    });
  } catch (error) {
    console.error('Error:', error.message);
  }
}

getVehicles();

Python Example

# Using the SDK
from carapis_arabam_parser import ArabamParser

parser = ArabamParser(
    api_key="arabam_parser_sk_1234567890abcdef1234567890abcdef",
    region="ankara"
)

# Extract vehicle listings
try:
    vehicles = parser.extract_listings(
        filters={
            "make": "Mercedes",
            "body_type": "SUV",
            "price_min": 500000
        },
        limit=10
    )

    print(f"Found {len(vehicles)} Mercedes SUVs")
    for vehicle in vehicles:
        print(f"{vehicle['year']} {vehicle['make']} {vehicle['model']} - {vehicle['price']['current']} TL")

except Exception as e:
    print(f"Error: {e}")

Direct API Call (cURL)

curl -X POST "https://api.carapis.com/v1/parsers/arabam.com/extract" \
  -H "Authorization: Bearer arabam_parser_sk_1234567890abcdef1234567890abcdef" \
  -H "Content-Type: application/json" \
  -d '{
    "filters": {
      "make": "Audi",
      "yearFrom": 2019,
      "priceMax": 800000
    },
    "options": {
      "region": "izmir",
      "limit": 5,
      "dataFields": ["price", "specifications", "seller_info"]
    }
  }'

Step 4: Understand the Response

Response Structure

The API returns a structured JSON response with vehicle data, pagination information, and metadata about the extraction process.

{
  "success": true,
  "data": {
    "vehicles": [
      {
        "id": "arabam_12345",
        "title": "2021 Audi A4 2.0 TDI",
        "url": "https://arabam.com/ilan/12345",
        "price": {
          "current": 750000,
          "currency": "TRY",
          "negotiable": true,
          "original": 780000,
          "monthly_payment": 12000,
          "down_payment": 150000
        },
        "specifications": {
          "make": "Audi",
          "model": "A4",
          "year": 2021,
          "trim": "2.0 TDI",
          "engine": "2.0L Diesel",
          "transmission": "Automatic",
          "mileage": 25000,
          "fuel_type": "Diesel",
          "body_type": "Sedan",
          "color": "White",
          "doors": 4,
          "seats": 5
        },
        "location": {
          "city": "İzmir",
          "district": "Konak",
          "province": "İzmir",
          "coordinates": [38.4192, 27.1287],
          "address": "Konak, İzmir, Turkey"
        },
        "seller": {
          "type": "dealer",
          "name": "Audi İzmir",
          "rating": 4.7,
          "verified": true,
          "phone": "+90 232 XXX XX XX",
          "email": "info@audiizmir.com",
          "address": "Konak, İzmir, Turkey",
          "business_hours": "Mon-Fri: 9AM-6PM"
        },
        "market_data": {
          "days_listed": 3,
          "views": 45,
          "price_trend": "stable",
          "market_position": "competitive",
          "similar_listings": 12
        },
        "features": ["Diesel Engine", "Automatic Transmission", "Navigation System", "Bluetooth Connectivity", "Backup Camera", "Leather Seats"],
        "history": {
          "accident_free": true,
          "owners_count": 1,
          "service_history": "Full service history available",
          "warranty": "Manufacturer warranty until 2024"
        },
        "extraction_time": "2024-01-15T10:30:00Z"
      }
    ],
    "pagination": {
      "total": 1250,
      "page": 1,
      "per_page": 5,
      "total_pages": 250
    },
    "metadata": {
      "extraction_time": "2024-01-15T10:30:00Z",
      "region": "izmir",
      "filters_applied": {
        "make": "Audi",
        "yearFrom": 2019,
        "priceMax": 800000
      }
    }
  }
}

Step 5: Common Use Cases

Extract All BMW Vehicles in Istanbul

const vehicles = await parser.extractListings({
  filters: {
    make: 'BMW',
    city: 'istanbul',
  },
  options: {
    limit: 100,
    dataFields: ['price', 'specifications', 'location'],
  },
});

console.log(`Found ${vehicles.length} BMW vehicles in Istanbul`);

Get Price Analysis for Mercedes SUVs

const vehicles = await parser.extractListings({
  filters: {
    make: 'Mercedes',
    bodyType: 'SUV',
    yearFrom: 2020,
  },
  options: {
    limit: 50,
    dataFields: ['price', 'market_data', 'specifications'],
  },
});

// Calculate average price
const avgPrice = vehicles.reduce((sum, v) => sum + v.price.current, 0) / vehicles.length;
console.log(`Average Mercedes SUV price: ${avgPrice.toLocaleString()} TL`);

// Price distribution analysis
const priceRanges = {
  'Under 500K': vehicles.filter((v) => v.price.current < 500000).length,
  '500K-1M': vehicles.filter((v) => v.price.current >= 500000 && v.price.current < 1000000).length,
  'Over 1M': vehicles.filter((v) => v.price.current >= 1000000).length,
};

console.log('Price distribution:', priceRanges);

Monitor Dealer Inventory

const dealerVehicles = await parser.extractListings({
  filters: {
    sellerType: 'dealer',
    city: 'ankara',
    yearFrom: 2019,
  },
  options: {
    limit: 200,
    dataFields: ['price', 'specifications', 'seller_info'],
  },
});

// Group by make
const inventoryByMake = dealerVehicles.reduce((acc, vehicle) => {
  const make = vehicle.specifications.make;
  acc[make] = (acc[make] || 0) + 1;
  return acc;
}, {});

console.log('Dealer inventory by make:', inventoryByMake);

Regional Price Comparison

const regions = ['istanbul', 'ankara', 'izmir', 'bursa'];
const priceData = {};

for (const region of regions) {
  const vehicles = await parser.extractListings({
    filters: {
      make: 'Toyota',
      model: 'Corolla',
      yearFrom: 2020,
    },
    options: {
      region,
      limit: 20,
      dataFields: ['price', 'location'],
    },
  });

  const avgPrice = vehicles.reduce((sum, v) => sum + v.price.current, 0) / vehicles.length;
  priceData[region] = avgPrice;
}

console.log('Regional Toyota Corolla prices:', priceData);

Step 6: Error Handling

Common Issues

Issue	Cause	Solution
401 Unauthorized	Invalid API key	Check key format and validity
429 Too Many Requests	Rate limit exceeded	Reduce request frequency
No results	Filters too restrictive	Broaden search criteria
Partial data	Network issues	Check connection stability
Timeout errors	Server overload	Retry with exponential backoff

JavaScript Error Handling

async function safeExtract(filters, options) {
  try {
    const vehicles = await parser.extractListings({ filters, options });
    return { success: true, data: vehicles };
  } catch (error) {
    if (error.status === 429) {
      // Rate limit exceeded - wait and retry
      await new Promise((resolve) => setTimeout(resolve, 60000));
      return safeExtract(filters, options);
    }

    console.error('Extraction failed:', error.message);
    return { success: false, error: error.message };
  }
}

// Usage
const result = await safeExtract({ make: 'BMW', yearFrom: 2020 }, { limit: 50 });

if (result.success) {
  console.log(`Found ${result.data.length} vehicles`);
} else {
  console.log('Extraction failed:', result.error);
}

Python Error Handling

import time
from carapis_arabam_parser import ArabamParser

def safe_extract(parser, filters, options):
    try:
        vehicles = parser.extract_listings(filters=filters, **options)
        return {"success": True, "data": vehicles}
    except Exception as e:
        if "429" in str(e):
            # Rate limit exceeded - wait and retry
            time.sleep(60)
            return safe_extract(parser, filters, options)

        print(f"Extraction failed: {e}")
        return {"success": False, "error": str(e)}

# Usage
result = safe_extract(
    parser,
    filters={"make": "BMW", "yearFrom": 2020},
    options={"limit": 50}
)

if result["success"]:
    print(f"Found {len(result['data'])} vehicles")
else:
    print("Extraction failed:", result["error"])

Step 7: Best Practices

Performance Optimization

Optimization Tips

• Use appropriate limits to avoid overwhelming the API
• Implement caching for frequently requested data
• Batch requests when possible for better efficiency
• Monitor rate limits to stay within quotas
• Use regional filtering to reduce data volume

Data Management

Data Handling

• Store API keys securely in environment variables
• Validate responses before processing data
• Handle pagination for large datasets
• Implement retry logic for failed requests
• Log errors for debugging and monitoring

Production Considerations

Production Setup

• Use environment variables for API keys
• Implement proper error handling with fallbacks
• Set up monitoring for API usage and errors
• Cache frequently accessed data to reduce API calls
• Test with real data before going live

Next Steps

Ready to Build?

1. View Features - Explore all available capabilities
2. API Reference - Complete endpoint documentation
3. Market Analysis - Turkish market insights
4. FAQ - Common questions and troubleshooting

Need Help?

• Support - Technical assistance and troubleshooting
• Examples - Live code examples and demos
• Community - Connect with other developers
• Documentation - Complete parser guide

Pro Tips

For Maximum Success

• Start with small requests to test your integration
• Use regional filtering to target specific Turkish markets
• Monitor your API usage to stay within limits
• Implement proper error handling for production use
• Cache frequently accessed data for better performance

Common Patterns

• Price monitoring for specific makes and models
• Inventory tracking for dealer networks
• Market analysis for investment decisions
• Regional comparisons for expansion planning
• Trend analysis for strategic insights

---

Start extracting comprehensive Turkish automotive data with enterprise-grade reliability and advanced anti-detection technology.

Get Started with Arabam.com Parser →