Webmotors.com.br Parser Quick Start

Get up and running with the Webmotors.com.br parser in minutes. Extract comprehensive automotive data from Brazil's largest automotive marketplace with just a few simple steps.

Webmotors.com.br Parser Quick Start Guide - Setup and Integration Tutorial

Step-by-step guide to get started with Webmotors.com.br automotive data extraction - from API setup to first data extraction in minutes

🚀 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

WebMotors Market Overview

WebMotors is Brazil's largest automotive marketplace with over 1M+ active listings covering São Paulo, Rio de Janeiro, and all major Brazilian cities. The platform features both new and used vehicles from dealerships and private sellers.

🔑 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 WebMotors API key will look like: webmotors_parser_sk_1234567890abcdef1234567890abcdef

🚗 Basic Usage Examples

Python Example

import requests
import json

# Configuration
API_KEY = "webmotors_parser_sk_your_api_key_here"
BASE_URL = "https://api.carapis.com/v1/parsers/webmotors"

# Search for Fiat cars in São Paulo
def search_fiat_sao_paulo():
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }

    params = {
        "brand": "Fiat",
        "location": "São Paulo",
        "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']['listings'])} Fiat listings in São Paulo")
        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']['formatted']}")
        print(f"Year: {vehicle['data']['vehicle']['specifications']['year']}")
        return vehicle
    else:
        print(f"Error: {response.status_code} - {response.text}")

# Example usage
if __name__ == "__main__":
    # Search for Fiat cars
    results = search_fiat_sao_paulo()

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

JavaScript Example

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

// Search for Honda cars in Rio de Janeiro
async function searchHondaRio() {
  const headers = {
    Authorization: `Bearer ${API_KEY}`,
    'Content-Type': 'application/json',
  };

  const params = new URLSearchParams({
    brand: 'Honda',
    location: 'Rio de Janeiro',
    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.listings.length} Honda listings in Rio de Janeiro`);
      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.formatted}`);
      console.log(`Year: ${vehicle.data.vehicle.specifications.year}`);
      return vehicle;
    } else {
      console.error(`Error: ${response.status} - ${response.statusText}`);
    }
  } catch (error) {
    console.error('Network error:', error);
  }
}

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

cURL Examples

# Search for Toyota cars in São Paulo
curl -X GET "https://api.carapis.com/v1/parsers/webmotors/search" \
  -H "Authorization: Bearer webmotors_parser_sk_your_api_key_here" \
  -H "Content-Type: application/json" \
  -G \
  -d "brand=Toyota" \
  -d "location=São Paulo" \
  -d "limit=5"

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

# Search with multiple filters
curl -X GET "https://api.carapis.com/v1/parsers/webmotors/search" \
  -H "Authorization: Bearer webmotors_parser_sk_your_api_key_here" \
  -H "Content-Type: application/json" \
  -G \
  -d "brand=Fiat" \
  -d "model=Argo" \
  -d "year_min=2020" \
  -d "price_max=80000" \
  -d "location=São Paulo"

🔍 Search Parameters

Available Search Filters

Parameter	Type	Description	Example
`brand`	string	Vehicle brand	"Fiat", "Honda", "Toyota"
`model`	string	Vehicle model	"Argo", "Civic", "Corolla"
`location`	string	City or state	"São Paulo", "Rio de Janeiro"
`year_min`	integer	Minimum year	2020
`year_max`	integer	Maximum year	2024
`price_min`	integer	Minimum price (BRL)	30000
`price_max`	integer	Maximum price (BRL)	100000
`fuel_type`	string	Fuel type	"Flex", "Gasolina", "Etanol"
`transmission`	string	Transmission type	"Manual", "Automático"
`limit`	integer	Results per page (max 100)	25
`page`	integer	Page number	1

📊 Response Format

Search Response

{
  "success": true,
  "data": {
    "listings": [
      {
        "id": "123456789",
        "title": "Fiat Argo Drive 1.3",
        "price": {
          "amount": 75000,
          "currency": "BRL",
          "formatted": "R$ 75.000"
        },
        "specifications": {
          "brand": "Fiat",
          "model": "Argo",
          "year": 2020,
          "mileage": 45000,
          "fuel_type": "Flex",
          "transmission": "Manual",
          "engine_size": "1.3L",
          "power": "109 hp",
          "doors": 5
        },
        "location": {
          "city": "São Paulo",
          "state": "SP",
          "country": "Brazil"
        },
        "seller": {
          "name": "Concessionária Fiat",
          "type": "dealer",
          "rating": 4.6,
          "certified": true
        },
        "url": "https://www.webmotors.com.br/...",
        "extracted_at": "2024-01-15T10:30:00Z"
      }
    ],
    "total_count": 850,
    "page": 1,
    "limit": 10
  }
}

Vehicle Details Response

{
  "success": true,
  "data": {
    "vehicle": {
      "id": "123456789",
      "title": "Fiat Argo Drive 1.3",
      "price": {
        "amount": 75000,
        "currency": "BRL",
        "formatted": "R$ 75.000",
        "negotiable": true,
        "financing_available": true
      },
      "specifications": {
        "brand": "Fiat",
        "model": "Argo",
        "year": 2020,
        "trim": "Drive",
        "mileage": 45000,
        "fuel_type": "Flex",
        "transmission": "Manual",
        "engine_size": "1.3L",
        "power": "109 hp",
        "torque": "139 Nm",
        "doors": 5,
        "seats": 5,
        "color": "Branco"
      },
      "location": {
        "city": "São Paulo",
        "state": "SP",
        "country": "Brazil",
        "coordinates": {
          "lat": -23.5505,
          "lng": -46.6333
        }
      },
      "seller": {
        "name": "Concessionária Fiat",
        "type": "dealer",
        "rating": 4.6,
        "certified": true,
        "phone": "+55 11 1234-5678",
        "address": "Rua das Flores, 123, São Paulo"
      },
      "features": ["Ar Condicionado", "Direção Hidráulica", "ABS", "Airbag", "Freios a Disco"],
      "images": ["https://example.com/image1.jpg", "https://example.com/image2.jpg"],
      "url": "https://www.webmotors.com.br/...",
      "extracted_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/webmotors/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))

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 filters - Narrow searches to reduce response time

🔧 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 Brazilian automotive 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​

Error Handling​

🚨 Rate Limits & Best Practices​

🔧 Troubleshooting​

Common Issues​

📈 Next Steps​