# Cars.co.ug Scraper: Used & New Cars in Uganda (`recordsdata/cars-ug-scraper`) Actor

Scrape cars.co.ug, the Ugandan car marketplace: used and new cars, SUVs, pick-ups and trucks with UGX, USD and EUR price, mileage, fuel, transmission, engine, photos, dealers and price-change monitoring. No login, no proxy. Export JSON, CSV or Excel.

- **URL**: https://apify.com/recordsdata/cars-ug-scraper.md
- **Developed by:** [RecordsData](https://apify.com/recordsdata) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $22.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

![RecordsData](https://api.apify.com/v2/key-value-stores/AAm3a1h3Z9nYfrvh9/records/banner?v=3)

## Cars.co.ug Scraper: Used and New Car Listings from Uganda

> Cars.co.ug Scraper is an Apify Actor that extracts vehicle listings from cars.co.ug, the Ugandan car marketplace for used and new cars, SUVs, pick-ups, vans, trucks and trailers. Each row has the price in Ugandan shillings (UGX) with the exact US dollar and euro price, year, mileage, engine, fuel, gearbox, drive, photos, city and seller type. It also returns dealer profiles and price-change rows. No login, no proxy and no browser are needed.

Export the result as JSON, CSV, Excel, XML or HTML, or read it through the Apify API. The actor reads the pages the site shows to visitors and paces its requests politely.

### What can you scrape from Cars.co.ug?

- **Vehicle listings**: the whole catalogue, 1,633 live ads on 2026-10-19 (1,569 used and 64 new), with price, year, mileage, engine size, fuel, transmission, city, seller type and the cover photo.
- **Detail pages** (optional): full photo gallery, equipment list, seller description, body type, drive type, power, fuel consumption, seats, finance flag, dealer address with map position and the exact US dollar and euro price.
- **Dealers**: the 13 car dealerships of the site with showroom address, map position, number of cars in stock and, on request, the business phone. Private sellers are listed as such and never identified.
- **Price changes**: with monitoring on, a repeat run returns only new listings, and a repriced listing comes back with the previous price and the change in percent.

### Why use this actor?

- **Whole catalogue reachable**: every page of every search can be read, so a full list read takes about two minutes and a full read with detail pages about 12 minutes.
- **Real filters, applied by the site and checked again on every row**: make, model, body type, fuel, transmission, city, condition, year, price, mileage and engine size.
- **Three currencies**: `price` in UGX as the site shows it, plus `priceUsd` and `priceEur` read from the listing page.
- **Clean, typed output**: numbers are numbers, enums are lowercase English, and absent values are left out instead of being filled with placeholders.
- **Privacy built in**: names and phone numbers of private sellers are never output, and phones and emails are removed from their descriptions.
- **Small and cheap to run**: 256 MB of memory, plain HTTP, about 0.1 cent of platform cost for a run of three listings.

### How to scrape Cars.co.ug car listings in four steps

1. Choose **What to collect** on the actor page.
2. Add makes such as `Toyota` or `Subaru`, or leave them empty, and set filters such as price, year or body type.
3. Set the maximum number of results and click **Start**.
4. Download the dataset from the **Storage** tab.

### Three ways to collect data

| Mode (`mode`) | Use it to | Record types |
|---|---|---|
| `search` | Find listings by make, model and the full filter set | `vehicle`, `price-change` |
| `urls` | Refresh known listings by number or address, replay a search address of the site, or read one dealer, one make or one model page | `vehicle`, `price-change`, `dealer` |
| `dealers` | List the car dealers and optionally their cars | `dealer`, `vehicle` |

Make and model names are not case sensitive and are checked against the site. An unknown name ends the run with one free error row that suggests close matches.

### Input

The form has 30 fields. These are the most used; the rest are in the input form of the actor page.

| Field | Type | Default | Meaning |
|---|---|---|---|
| `mode` | string | `search` | What to collect: `search`, `urls` or `dealers` |
| `maxItems` | integer | 50 | Maximum results (free plans: 10) |
| `makes` | array | empty | Makes as written on the site, for example `Toyota` |
| `models` | array | empty | Models of ONE make, for example `Land Cruiser` |
| `bodyTypes` | array | empty | `suv`, `sedan`, `station-wagon`, `pickup-double-cab`, `panel-van`, `minibus`, `mpv`, `hatchback`, `coupe` and more |
| `fuelTypes` | array | empty | `petrol`, `diesel`, `hybrid` |
| `cities` | array | empty | `kampala`, `entebbe` |
| `transmission` | string | `any` | `manual` or `automatic` (automatic also covers DSG and multitronic, as on the site) |
| `condition` | string | `any` | `new` or `used` |
| `yearFrom` / `yearTo` | integer | none | Model year range |
| `priceFrom` / `priceTo` | integer | none | Price range in UGX |
| `mileageFrom` / `mileageTo` | integer | none | Odometer range in km |
| `engineFrom` / `engineTo` | integer | none | Engine size range in cc |
| `sortBy` | string | `newest` | `newest`, `oldest`, `price-asc`, `price-desc`, `mileage-asc`, `mileage-desc`, `year-desc`, `year-asc` |
| `startUrls` / `listingIds` | array | empty | Addresses and listing numbers for `urls` mode |
| `fetchDetails` | boolean | false | Open every listing page for the full gallery, equipment and seller block |
| `includeContactDetails` | boolean | false | Add dealer business phones |
| `onlyNew` / `trackPriceChanges` | boolean | false | Monitor mode: only new listings, and price-change rows |

A minimal example input:

```json
{
  "mode": "search",
  "makes": ["Toyota"],
  "models": ["Land Cruiser"],
  "bodyTypes": ["suv"],
  "fuelTypes": ["diesel"],
  "yearFrom": 2018,
  "sortBy": "price-asc",
  "maxItems": 100
}
```

### What data do you get?

Every row has a `recordType`: `vehicle`, `price-change` or `dealer`. Fields that do not apply to a record type, or that the site does not show for a listing, are left out.

| Field | Description |
|---|---|
| `recordType` | The record type |
| `listingId`, `dealerId` | Listing number and dealer number |
| `title`, `url`, `imageUrl` | Listing title, address and cover photo |
| `make`, `model`, `year` | Make, model and model year |
| `bodyType`, `fuelType`, `transmission`, `driveType` | Specification: body as the site names it, fuel and transmission as lowercase English enums (`manual`, `automatic`, `other`), drive as the site names it |
| `engineSize`, `engineSizeUnit` | Engine size in litres with its unit `L` |
| `powerKw`, `powerHp`, `fuelConsumption`, `seats`, `loadCapacityTons` | Power in kW and horsepower, fuel use in litres per 100 km, seats and load capacity, when the seller entered them (detail rows) |
| `mileage`, `mileageUnit`, `condition` | Odometer in km and `new` or `used` |
| `price`, `currency` | Asking price in UGX |
| `priceUsd`, `priceEur` | Exact US dollar and euro price shown on the listing page (detail rows) |
| `previousPrice`, `priceChange`, `priceChangePct`, `changeType` | Price-change rows: old price, difference, percent, `price-drop` or `price-increase` |
| `financeAvailable` | Whether the seller offers finance (detail rows) |
| `country`, `city`, `address`, `latitude`, `longitude` | Where the vehicle or dealership is; address and map position are the dealership showroom (detail rows and dealer rows) |
| `features`, `description` | Equipment list and the seller's text, with contacts removed (detail rows) |
| `images`, `imageCount` | Full-size gallery and photo count (detail rows) |
| `sellerType`, `isPrivateSeller`, `sellerName`, `sellerUrl`, `sellerLogo` | `dealer` or `private`; dealer identity is filled for dealers only |
| `sellerPhone`, `phones` | Dealer business phone, only with **Include dealer contact details** |
| `vehicleCount` | Dealer rows: number of cars in stock |
| `sourceSite`, `scrapedAt` | `cars.co.ug` and the time of extraction |

#### Sample output

A real `vehicle` row with detail pages on, from a cloud run (photo list, equipment and description shortened):

```json
{
  "imageUrl": "https://www.cars.co.ug/Uganda/used-cars/2024-Toyota-LAND-CRUISER-LC300-ZX-2024-928-1480118_1.jpg",
  "recordType": "vehicle",
  "title": "2024 Toyota LAND CRUISER LC300 ZX",
  "listingId": "41315",
  "dealerId": "928",
  "url": "https://www.cars.co.ug/Toyota-LAND-CRUISER-LC300-ZX-2024-41315",
  "sourceSite": "cars.co.ug",
  "country": "Uganda",
  "city": "Kampala",
  "address": "CADAM ENTREPRISES NAGURU ROAD-OFF LUGOGO BY PASS KAMPALA",
  "latitude": 0.330955,
  "longitude": 32.6036,
  "make": "Toyota",
  "model": "LAND CRUISER LC300 ZX",
  "year": 2024,
  "bodyType": "SUV",
  "fuelType": "diesel",
  "transmission": "automatic",
  "driveType": "4x4",
  "engineSize": 3.3,
  "engineSizeUnit": "L",
  "condition": "used",
  "price": 450000000,
  "currency": "UGX",
  "priceUsd": 108641,
  "priceEur": 96773,
  "financeAvailable": true,
  "features": ["Air Conditioning", "Cruise Control", "Electric Mirrors", "Power Steering"],
  "description": "TOYOTA LAND LC300 ZX 2024 INVESTMENT UGX 450M",
  "images": [
    "https://www.cars.co.ug/Uganda/used-cars/2024-Toyota-LAND-CRUISER-LC300-ZX-2024-928-1480118_1.jpg",
    "https://www.cars.co.ug/Uganda/used-cars/2024-Toyota-LAND-CRUISER-LC300-ZX-2024-928-1480118_2.jpg"
  ],
  "imageCount": 22,
  "sellerType": "dealer",
  "isPrivateSeller": false,
  "sellerName": "SEPHOC MOTORS UGANDA",
  "sellerUrl": "https://www.cars.co.ug/SEPHOC-MOTORS-UGANDA",
  "sellerLogo": "https://www.cars.co.ug/image/928/dealerlogo/SEPHOC-MOTORS-UGANDA",
  "scrapedAt": "2026-10-19T07:10:24.857Z"
}
```

### How much does it cost to scrape Cars.co.ug?

The actor is billed per result with Apify pay-per-event pricing:

| Event | What you pay for | Price per result | Per 1,000 |
|---|---|---|---|
| Vehicle record | One listing read from the result list | $0.0015 | $1.50 |
| Vehicle detail record | One listing with its detail page | $0.0023 | $2.30 |
| Price change record | One listing whose price moved | $0.0015 | $1.50 |
| Dealer record | One dealer | $0.0023 | $2.30 |

Worked examples:

- The whole catalogue from the result list: 1,633 x $0.0015 = $2.45.
- The whole catalogue with detail pages: 1,633 x $0.0023 = $3.76.
- A daily monitor run that finds 12 new listings and 3 price changes costs 12 x $0.0015 + 3 x $0.0015 = $0.02.

Error rows, empty searches and listings skipped by monitoring are never charged. Apify platform usage for a run of three listings is about $0.0001.

### How does it compare with other car scrapers?

No other actor on the Apify Store reads cars.co.ug (Store search on 2026-10-19: no result for the site, its name or Uganda car listings). The general car scrapers cover other marketplaces: for example memo23/facebook-marketplace-scraper-ppe and 3x1t/mobile-de-scraper-ppr both charge $1.50 per 1,000 results.

This actor's result-list price is the same $1.50 per 1,000 and it returns the Ugandan marketplace with dealers, price-change monitoring and both UGX and USD prices.

### Is it legal to scrape Cars.co.ug? Limits and responsible use

The actor reads public listing pages. It does not log in or bypass any protection, and it keeps a gap of about half a second between requests; the site's robots.txt allows these pages and sets no crawl delay. Private sellers' names and phone numbers are never output, and contacts are removed from private descriptions. Dealer business phones only appear with **Include dealer contact details**. You are responsible for using the data in line with the site terms and Ugandan data protection law.

Limits:

- The site prints UGX prices in millions with two decimals, so `price` is accurate to about 5,000 shillings. Listings priced in US dollars show a converted UGX price; `priceUsd` on detail rows is the exact dollar amount.
- A used listing that shows 0 km has no stated mileage; `mileage` is left out. A 0 km reading is kept only for new vehicles.
- The site shows no publication date, no view count and no VIN, so those fields do not exist.
- Power and fuel use are filled for only a few percent of ads, because sellers often leave the form placeholders.
- A sort by price, mileage or year can repeat or skip rows between result pages on the site; the actor fills the gaps with a second newest-first pass, and those rows come last.
- Free Apify plans are limited to 10 results per run.

### Use with AI agents (MCP)

Connect the Apify MCP server to Claude, Cursor or another MCP client and this actor appears as a tool: `https://mcp.apify.com?tools=RecordsData/cars-ug-scraper`.

Example prompt: "Find the 20 cheapest diesel Toyota Land Cruiser SUVs from 2018 or newer on Cars.co.ug and list price in UGX and USD, mileage and dealer." The agent sends `{ "mode": "search", "makes": ["Toyota"], "models": ["Land Cruiser"], "bodyTypes": ["suv"], "fuelTypes": ["diesel"], "yearFrom": 2018, "sortBy": "price-asc", "fetchDetails": true, "maxItems": 20 }` and analyzes the rows.

### Run it from code

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('RecordsData/cars-ug-scraper').call({
    mode: 'search',
    makes: ['Toyota'],
    yearFrom: 2018,
    maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, items[0].title, items[0].price);
```

You can also call the actor from the Python client, Make, Zapier or n8n, and schedule it from the Apify Console.

### Frequently Asked Questions

#### Which vehicles does it cover?

Everything listed on cars.co.ug: used and new cars, SUVs, pick-ups, vans, minibuses, trucks and trailers, from dealers and private sellers. The condition (`new` or `used`) is the label the site shows on the ad.

#### Do I need a proxy, a login or an API key?

No. The actor makes plain HTTP requests to the public site and needs no proxy, browser or Cars.co.ug account. You only need an Apify account to start runs, and the free plan returns up to 10 results per run.

#### Is it legal to scrape Cars.co.ug?

The actor reads publicly visible listings and does not log in. It keeps a polite request pace and respects the site's robots.txt. Private sellers' personal data is not output; you remain responsible for how you use the data.

#### How much does a run cost?

The actor is billed per result: $0.0015 per vehicle listing, $0.0023 per listing with its detail page, $0.0015 per price change and $0.0023 per dealer. So 1,000 vehicle listings cost $1.50. The Pricing tab of the actor page shows the live rate. Error rows and listings skipped by monitoring are never charged.

#### Why is the price in shillings and what are priceUsd and priceEur?

The site shows prices in Ugandan shillings, so `price` is in UGX. Detail rows add `priceUsd` and `priceEur`, read from the exact dollar and euro figures on the listing page. Sellers who list in US dollars appear in shillings at the site's own rate.

#### Why is there no phone number in the rows?

Dealer phones are returned only when you switch on **Include dealer contact details**, and only for dealers, which are businesses. Private sellers' phones and names are never returned, and contacts are also removed from private descriptions.

#### Why does a used car have no mileage?

Many sellers leave the odometer empty and the site then prints 0 km. The actor treats that as unknown and leaves `mileage` out, so a mileage filter never matches a listing without a stated mileage. New vehicles are kept at 0 km.

#### Can I get only the listings published since my last run?

Yes. Switch on **Only new listings (monitor)** and keep the same search settings, or the same **Monitor name**. Add **Report price changes** to also get a row when a price moves by 2 percent or more. Scheduled runs then return only new or repriced listings, never charged twice.

#### How many results can I get in one run?

The site sets no cap: all 1,633 listings are reachable. A read of the result list takes about two minutes and a full read with detail pages about 12 minutes. Set `maxItems` to what you need. Free Apify plans are limited to 10 results per run; paid plans use the value you set.

#### What happens when the search finds nothing or the input is wrong?

A search with no hits ends as succeeded with an empty dataset and charges nothing. A wrong input value, such as a minimum year above the maximum or an unknown make, ends as succeeded with one free error row that explains the problem, so a typo never costs you money.

### Support

Questions, a missing field or a feature request: contact.punkrecordsdata@gmail.com. Reviews on the actor page help other people find it.

This actor is an independent tool and is not affiliated with cars.co.ug.

# Actor input Schema

## `mode` (type: `string`):

search = vehicle ads for the makes and filters below. urls = listing addresses, listing numbers, search addresses and dealer pages you list. dealers = the car dealer directory with showroom address, map position and stock counts.

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

Stops after this many rows (all record types together). Free plans are limited to 10 items per run. The whole site is about 1,600 vehicles.

## `makes` (type: `array`):

Car makes as written on the site, for example Toyota, Nissan, Subaru or Mercedes-Benz. Case and spaces do not matter. An unknown make is reported with close suggestions. Empty means every make.

## `models` (type: `array`):

Models of ONE make, for example Land Cruiser, Hilux or Harrier. Needs exactly one entry in Makes. A model that does not exist for the make is reported with examples.

## `bodyTypes` (type: `array`):

Body styles to keep. Leave empty for all.

## `fuelTypes` (type: `array`):

Fuel types to keep. Leave empty for all.

## `cities` (type: `array`):

Cities with ads: Kampala (nearly every ad) and Entebbe. Leave empty for all.

## `transmission` (type: `string`):

Manual keeps manual gearboxes only. Automatic keeps everything that is not manual (automatic, DSG, multitronic and similar), as the site does.

## `condition` (type: `string`):

New or used, as labelled on the ad.

## `yearFrom` (type: `integer`):

Only vehicles of this model year or newer. 0 or empty means no limit.

## `yearTo` (type: `integer`):

Only vehicles of this model year or older. 0 or empty means no limit.

## `priceFrom` (type: `integer`):

Only ads priced at or above this amount in Ugandan shillings, for example 50000000. 0 or empty means no limit.

## `priceTo` (type: `integer`):

Only ads priced at or below this amount in Ugandan shillings. 0 or empty means no limit.

## `mileageFrom` (type: `integer`):

Only vehicles with at least this odometer reading. Ads that do not state a mileage are left out when a mileage limit is set. 0 or empty means no limit.

## `mileageTo` (type: `integer`):

Only vehicles with at most this odometer reading. Ads that do not state a mileage are left out when a mileage limit is set. 0 or empty means no limit.

## `engineFrom` (type: `integer`):

Only engines of at least this size in cubic centimetres, for example 2000. 0 or empty means no limit.

## `engineTo` (type: `integer`):

Only engines of at most this size in cubic centimetres, for example 3000. 0 or empty means no limit.

## `sortBy` (type: `string`):

Order of the results. Newest first is best for monitoring and is the fastest.

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

urls mode. cars.co.ug listing pages, search result pages with filters, make or model pages (for example /Toyota/Land-Cruiser), body-type pages, one dealer page or the private sellers page. Listing numbers can go in the next field.

## `listingIds` (type: `array`):

urls mode. The number at the end of a listing address, for example 41316. Four to nine digits.

## `dealerQuery` (type: `string`):

dealers mode. Keeps only dealers whose name contains this text. Empty means every dealer.

## `includeDealerVehicles` (type: `boolean`):

On: after each dealer record, also read that dealer's vehicle listings (each one is a vehicle record).

## `fetchDetails` (type: `boolean`):

Off: one row per ad from the result list (price, year, mileage, fuel, transmission, city, photo). On: also opens each ad page for body type, drive, power, features, all photos, description, dealer address and map position, and the exact US dollar and euro price. Slower and billed as a detail record.

## `includeContactDetails` (type: `boolean`):

Adds the business phone of dealerships and keeps phone numbers inside their descriptions. Private seller names, phones and emails are never output.

## `onlyNew` (type: `boolean`):

Skips every listing seen in an earlier run with the same monitor name, so scheduled runs return only what is new.

## `trackPriceChanges` (type: `boolean`):

Needs Only new listings. A listing seen before with a price at least 2 percent different comes back as a price-change-record with the previous price and the change in percent.

## `resetSeen` (type: `boolean`):

Clears the memory of the monitor name before this run.

## `stateKey` (type: `string`):

Name of the memory used by Only new listings. Use one name per saved search. Empty derives a name from your filters.

## `maxConcurrency` (type: `integer`):

How many listing pages are read at the same time (1 to 5). Requests are paced to about two per second in total, so a higher value adds little.

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

Optional. Empty means direct requests, which work. Add a proxy only if your own network needs one.

## Actor input object example

```json
{
  "mode": "search",
  "maxItems": 10,
  "makes": [
    "Toyota"
  ],
  "models": [],
  "bodyTypes": [],
  "fuelTypes": [],
  "cities": [],
  "transmission": "any",
  "condition": "any",
  "sortBy": "newest",
  "startUrls": [],
  "listingIds": [],
  "dealerQuery": "",
  "includeDealerVehicles": false,
  "fetchDetails": false,
  "includeContactDetails": false,
  "onlyNew": false,
  "trackPriceChanges": false,
  "resetSeen": false,
  "stateKey": "",
  "maxConcurrency": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

Key fields per row

## `fullData` (type: `string`):

Complete dataset with all fields

# 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 = {
    "maxItems": 10,
    "makes": [
        "Toyota"
    ],
    "models": [],
    "yearFrom": 0,
    "yearTo": 0,
    "priceFrom": 0,
    "priceTo": 0,
    "mileageFrom": 0,
    "mileageTo": 0,
    "engineFrom": 0,
    "engineTo": 0,
    "startUrls": [],
    "listingIds": [],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("recordsdata/cars-ug-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 = {
    "maxItems": 10,
    "makes": ["Toyota"],
    "models": [],
    "yearFrom": 0,
    "yearTo": 0,
    "priceFrom": 0,
    "priceTo": 0,
    "mileageFrom": 0,
    "mileageTo": 0,
    "engineFrom": 0,
    "engineTo": 0,
    "startUrls": [],
    "listingIds": [],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("recordsdata/cars-ug-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 '{
  "maxItems": 10,
  "makes": [
    "Toyota"
  ],
  "models": [],
  "yearFrom": 0,
  "yearTo": 0,
  "priceFrom": 0,
  "priceTo": 0,
  "mileageFrom": 0,
  "mileageTo": 0,
  "engineFrom": 0,
  "engineTo": 0,
  "startUrls": [],
  "listingIds": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call recordsdata/cars-ug-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,recordsdata/cars-ug-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/KtQp92D4boBtGF0b1/builds/UO7LzDcgpPddLfK9u/openapi.json