🚀 Spinny Parser Quick Start

Get real-time automotive data from India's fastest-growing used car marketplace in under 5 minutes

What You'll Get

Real-time Spinny data - Live listings from India's #1 used car marketplace
Quality-assured vehicles - 140-point inspection reports for every vehicle
Fixed pricing data - No-negotiation pricing with complete transparency
Financing integration - EMI calculations and loan approval data
Multiple output formats - JSON, CSV, Excel for your workflow

📋 Prerequisites

Before you begin, ensure you have:

Carapis API Key - Get your free key here
Basic programming knowledge - Python, JavaScript, or cURL
Internet connection - For API access

:::

Quick Start

info Spinny Market Overview Spinny is India's fastest-growing used car marketplace with 50,000+ quality-assured vehicles across 15+ major cities. The platform features a unique 140-point inspection system and no-negotiation pricing model, revolutionizing the Indian used car industry. :::

🔑 Authentication Setup

1. Get Your API Key

# Sign up at Carapis Dashboard
curl -X POST "https://api.carapis.com/auth/register" \
  -H "Content-Type: application/json" \
  -d '{
    "email": "your-email@example.com",
    "password": "your-secure-password"
  }'

2. Retrieve Your API Key

# Login and get your API key
curl -X POST "https://api.carapis.com/auth/login" \
  -H "Content-Type: application/json" \
  -d '{
    "email": "your-email@example.com",
    "password": "your-secure-password"
  }'

API Key Format

Your Spinny API key will look like: spinny_parser_sk_1234567890abcdef1234567890abcdef

🚗 Basic Usage Examples

Python Example

import requests
import json

# Configuration
API_KEY = "spinny_parser_sk_your_api_key_here"
BASE_URL = "https://api.carapis.com/v1/parsers/spinny"

# Search for Maruti Suzuki cars in Mumbai
def search_maruti_mumbai():
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }

    params = {
        "make": "Maruti Suzuki",
        "city": "Mumbai",
        "limit": 10
    }

    response = requests.get(f"{BASE_URL}/search", headers=headers, params=params)

    if response.status_code == 200:
        data = response.json()
        print(f"Found {len(data['data']['vehicles'])} Maruti Suzuki listings in Mumbai")
        return data
    else:
        print(f"Error: {response.status_code} - {response.text}")

# Get detailed vehicle information
def get_vehicle_details(vehicle_id):
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }

    response = requests.get(f"{BASE_URL}/vehicle/{vehicle_id}", headers=headers)

    if response.status_code == 200:
        vehicle = response.json()
        print(f"Vehicle: {vehicle['data']['vehicle']['title']}")
        print(f"Price: {vehicle['data']['vehicle']['price']['fixed_price']} INR")
        print(f"Quality Rating: {vehicle['data']['vehicle']['quality_assurance']['quality_rating']}")
        return vehicle
    else:
        print(f"Error: {response.status_code} - {response.text}")

# Example usage
if __name__ == "__main__":
    # Search for Maruti Suzuki cars
    results = search_maruti_mumbai()

    # Get details of first result
    if results and results['data']['vehicles']:
        first_vehicle = results['data']['vehicles'][0]
        get_vehicle_details(first_vehicle['id'])

JavaScript Example

// Configuration
const API_KEY = 'spinny_parser_sk_your_api_key_here';
const BASE_URL = 'https://api.carapis.com/v1/parsers/spinny';

// Search for Hyundai cars in Delhi
async function searchHyundaiDelhi() {
  const headers = {
    Authorization: `Bearer ${API_KEY}`,
    'Content-Type': 'application/json',
  };

  const params = new URLSearchParams({
    make: 'Hyundai',
    city: 'Delhi',
    limit: '10',
  });

  try {
    const response = await fetch(`${BASE_URL}/search?${params}`, {
      method: 'GET',
      headers: headers,
    });

    if (response.ok) {
      const data = await response.json();
      console.log(`Found ${data.data.vehicles.length} Hyundai listings in Delhi`);
      return data;
    } else {
      console.error(`Error: ${response.status} - ${response.statusText}`);
    }
  } catch (error) {
    console.error('Network error:', error);
  }
}

// Get vehicle details
async function getVehicleDetails(vehicleId) {
  const headers = {
    Authorization: `Bearer ${API_KEY}`,
    'Content-Type': 'application/json',
  };

  try {
    const response = await fetch(`${BASE_URL}/vehicle/${vehicleId}`, {
      method: 'GET',
      headers: headers,
    });

    if (response.ok) {
      const vehicle = await response.json();
      console.log(`Vehicle: ${vehicle.data.vehicle.title}`);
      console.log(`Price: ${vehicle.data.vehicle.price.fixed_price} INR`);
      console.log(`Quality Rating: ${vehicle.data.vehicle.quality_assurance.quality_rating}`);
      return vehicle;
    } else {
      console.error(`Error: ${response.status} - ${response.statusText}`);
    }
  } catch (error) {
    console.error('Network error:', error);
  }
}

// Example usage
searchHyundaiDelhi().then((results) => {
  if (results && results.data.vehicles.length > 0) {
    getVehicleDetails(results.data.vehicles[0].id);
  }
});

cURL Examples

# Search for Honda cars in Bangalore
curl -X GET "https://api.carapis.com/v1/parsers/spinny/search" \
  -H "Authorization: Bearer spinny_parser_sk_your_api_key_here" \
  -H "Content-Type: application/json" \
  -G \
  -d "make=Honda" \
  -d "city=Bangalore" \
  -d "limit=5"

# Get specific vehicle details
curl -X GET "https://api.carapis.com/v1/parsers/spinny/vehicle/12345" \
  -H "Authorization: Bearer spinny_parser_sk_your_api_key_here" \
  -H "Content-Type: application/json"

# Search with quality filters
curl -X GET "https://api.carapis.com/v1/parsers/spinny/search" \
  -H "Authorization: Bearer spinny_parser_sk_your_api_key_here" \
  -H "Content-Type: application/json" \
  -G \
  -d "make=Toyota" \
  -d "quality_rating=excellent" \
  -d "price_max=1000000" \
  -d "city=Mumbai"

🔍 Search Parameters

Available Search Filters

Parameter	Type	Description	Example
`make`	string	Vehicle brand	"Maruti Suzuki", "Hyundai"
`model`	string	Vehicle model	"Swift", "i20"
`city`	string	City name	"Mumbai", "Delhi", "Bangalore"
`year_min`	integer	Minimum year	2018
`year_max`	integer	Maximum year	2024
`price_min`	integer	Minimum price (INR)	300000
`price_max`	integer	Maximum price (INR)	1500000
`fuel_type`	string	Fuel type	"Petrol", "Diesel"
`transmission`	string	Transmission type	"Manual", "Automatic"
`quality_rating`	string	Quality rating	"excellent", "good", "fair"
`body_type`	string	Body type	"Hatchback", "Sedan", "SUV"
`limit`	integer	Results per page (max 100)	25
`page`	integer	Page number	1

📊 Response Format

Search Response

{
  "success": true,
  "data": {
    "vehicles": [
      {
        "id": "spinny_12345",
        "title": "2019 Maruti Suzuki Swift VXI",
        "price": {
          "fixed_price": 650000,
          "currency": "INR",
          "emi_monthly": 12500,
          "down_payment": 130000,
          "negotiable": false
        },
        "specifications": {
          "make": "Maruti Suzuki",
          "model": "Swift",
          "year": 2019,
          "variant": "VXI",
          "engine": "1.2L K-Series",
          "transmission": "Manual",
          "mileage": 25000,
          "fuel_type": "Petrol",
          "body_type": "Hatchback"
        },
        "quality_assurance": {
          "inspection_score": 95,
          "quality_rating": "excellent"
        },
        "location": {
          "city": "Mumbai",
          "dealer_name": "Spinny Mumbai Central"
        },
        "url": "https://www.spinny.com/used-cars/mumbai/maruti-suzuki-swift-vxi-2019",
        "created_at": "2024-01-15T10:30:00Z"
      }
    ],
    "total_results": 1250,
    "page": 1,
    "limit": 10
  }
}

Vehicle Details Response

{
  "success": true,
  "data": {
    "vehicle": {
      "id": "spinny_12345",
      "title": "2019 Maruti Suzuki Swift VXI",
      "price": {
        "fixed_price": 650000,
        "currency": "INR",
        "emi_monthly": 12500,
        "down_payment": 130000,
        "negotiable": false,
        "insurance_estimate": 15000
      },
      "specifications": {
        "make": "Maruti Suzuki",
        "model": "Swift",
        "year": 2019,
        "variant": "VXI",
        "engine": "1.2L K-Series",
        "transmission": "Manual",
        "mileage": 25000,
        "fuel_type": "Petrol",
        "body_type": "Hatchback",
        "color": "Pearl Arctic White",
        "seats": 5,
        "doors": 5
      },
      "quality_assurance": {
        "inspection_score": 95,
        "quality_rating": "excellent",
        "inspection_date": "2024-01-15",
        "warranty_months": 12,
        "service_history": "complete",
        "inspection_report": {
          "engine_performance": "excellent",
          "exterior_condition": "excellent",
          "interior_condition": "excellent",
          "safety_features": "excellent"
        }
      },
      "location": {
        "city": "Mumbai",
        "state": "Maharashtra",
        "dealer_name": "Spinny Mumbai Central",
        "dealer_address": "123, Andheri West, Mumbai",
        "home_delivery": true,
        "delivery_cost": 0
      },
      "features": ["Power Steering", "Air Conditioning", "Power Windows", "Central Locking", "Music System", "ABS", "Airbags"],
      "financing": {
        "available": true,
        "partners": ["HDFC Bank", "ICICI Bank"],
        "interest_rate": "8.5%",
        "tenure_options": [12, 24, 36, 48, 60]
      },
      "url": "https://www.spinny.com/used-cars/mumbai/maruti-suzuki-swift-vxi-2019",
      "created_at": "2024-01-15T10:30:00Z",
      "updated_at": "2024-01-20T14:15:00Z"
    }
  }
}

⚡ Advanced Usage

Batch Processing

import asyncio
import aiohttp
import json

async def batch_vehicle_details(vehicle_ids, api_key):
    async with aiohttp.ClientSession() as session:
        tasks = []
        for vehicle_id in vehicle_ids:
            task = get_vehicle_async(session, vehicle_id, api_key)
            tasks.append(task)

        results = await asyncio.gather(*tasks, return_exceptions=True)
        return results

async def get_vehicle_async(session, vehicle_id, api_key):
    headers = {"Authorization": f"Bearer {api_key}"}
    url = f"https://api.carapis.com/v1/parsers/spinny/vehicle/{vehicle_id}"

    async with session.get(url, headers=headers) as response:
        if response.status == 200:
            return await response.json()
        else:
            return {"error": f"Failed to fetch vehicle {vehicle_id}"}

# Usage
vehicle_ids = ["12345", "12346", "12347", "12348", "12349"]
results = asyncio.run(batch_vehicle_details(vehicle_ids, API_KEY))

Quality Filtering

def get_excellent_quality_vehicles(city, make):
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }

    params = {
        "city": city,
        "make": make,
        "quality_rating": "excellent",
        "limit": 50
    }

    response = requests.get(f"{BASE_URL}/search", headers=headers, params=params)

    if response.status_code == 200:
        data = response.json()
        excellent_vehicles = data['data']['vehicles']
        print(f"Found {len(excellent_vehicles)} excellent quality {make} vehicles in {city}")
        return excellent_vehicles
    else:
        print(f"Error: {response.status_code} - {response.text}")
        return []

# Usage
excellent_swifts = get_excellent_quality_vehicles("Mumbai", "Maruti Suzuki")

Error Handling

import requests
from requests.exceptions import RequestException
import time

def robust_api_call(url, headers, max_retries=3):
    for attempt in range(max_retries):
        try:
            response = requests.get(url, headers=headers, timeout=30)
            response.raise_for_status()
            return response.json()
        except RequestException as e:
            if attempt == max_retries - 1:
                raise e
            time.sleep(2 ** attempt)  # Exponential backoff
        except Exception as e:
            print(f"Unexpected error: {e}")
            if attempt == max_retries - 1:
                raise e
            time.sleep(1)

🚨 Rate Limits & Best Practices

Rate Limits

Free Plan: 1,000 requests/day
Pro Plan: 10,000 requests/day
Enterprise: Custom limits

Best Practices

Use pagination - Process results in batches of 25-50
Implement caching - Store results to avoid duplicate requests
Handle errors gracefully - Implement retry logic with exponential backoff
Monitor usage - Track API calls to stay within limits
Use quality filters - Filter by quality rating for better results

🔧 Troubleshooting

Common Issues

Authentication Errors

Error: 401 Unauthorized Solution: Verify your API key is correct and active

Rate Limit Exceeded

Error: 429 Too Many Requests Solution: Implement rate limiting or upgrade your plan

Invalid Parameters

Error: 400 Bad Request Solution: Check parameter names and values in documentation

📈 Next Steps

Ready to Scale?

View API Reference - Complete endpoint documentation
Market Analysis - Understand Indian used car trends
Integration Examples - Advanced use cases
FAQ - Common questions and solutions

Need help? Contact our support team or check our comprehensive documentation.

📋 Prerequisites​

🔑 Authentication Setup​

1. Get Your API Key​

2. Retrieve Your API Key​

🚗 Basic Usage Examples​

Python Example​

JavaScript Example​

cURL Examples​

🔍 Search Parameters​

📊 Response Format​

Search Response​

Vehicle Details Response​

⚡ Advanced Usage​

Batch Processing​

Quality Filtering​

Error Handling​

🚨 Rate Limits & Best Practices​

🔧 Troubleshooting​

Common Issues​

📈 Next Steps​