# UA Cars Monitor — AUTO.RIA + RST.ua Price Gaps & Alerts | $2/1k (`skipper_lume/ua-cars-monitor`) Actor

Run AUTO.RIA and RST.ua scrapers together, match the same cars across marketplaces, and emit priceGapUSD + a webhook-friendly digest (new / drops / delisted). The only dual-marketplace Ukraine used-car monitor on Apify.

- **URL**: https://apify.com/skipper\_lume/ua-cars-monitor.md
- **Developed by:** [Maksym Horbachov](https://apify.com/skipper_lume) (community)
- **Categories:** Automation, E-commerce, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## UA Cars Monitor — AUTO.RIA + RST.ua | Price Gaps & Digests | $2/1k

Run **both** major Ukrainian used-car marketplaces in one Actor, match likely-same cars, and get **`priceGapUSD`** plus a webhook-friendly **digest**.

> Child scrapers are billed at their own PPE ($1/1k each). This monitor adds merge + digest at **$2.00 / 1,000 output rows**.

### Why this exists

| Alone | With UA Cars Monitor |
|-------|----------------------|
| Scrape AUTO.RIA **or** RST | Scrape **both**, same filters |
| Manual Excel matching | Automatic pairs + `cheaperMarketplace` |
| Raw listing dumps | One `digest` row for Slack/Make webhooks |

There is **no other dual-marketplace Ukraine car monitor** on Apify.

### Quick start (Store QA / demo)

```json
{
    "brandName": "Toyota",
    "modelName": "Camry",
    "maxResults": 10,
    "outputMode": "pairs_and_listings",
    "emitDigest": true
}
````

Schedule daily + attach Integrations → get “3 drops, top gap $1,200 on RST” without opening CSV.

### Alerts (Slack or Telegram) — Apify Integrations

You set this up yourself in Console — we don’t need access to your chats.

#### Easiest path: Telegram via Make.com (no code)

1. In Apify: **Create task** → paste input with `"emitDigest": true` → **Save**.
2. Task → **Schedule** → Daily.
3. Task → **Integrations** → **Webhooks** → add webhook
   - Event: **Actor run succeeded**
   - URL: you’ll get this from Make in step 5.
4. In [Make.com](https://www.make.com): new scenario
   - Module 1: **Webhooks → Custom webhook** → copy URL → paste into Apify (step 3) → Save & Test.
   - Module 2: **Apify → Get Dataset Items** (use Dataset ID from the webhook payload / run).
   - Filter: keep items where `type` equals `digest`.
   - Module 3: **Telegram Bot → Send a Text Message** (connect your bot + chat).
5. Run the task once → you should get a Telegram message with the digest summary.

**Bot setup (once):** talk to [@BotFather](https://t.me/BotFather) → `/newbot` → copy token. Add the bot to your group (or DM it), then in Make pick that chat.

Message idea: send `headline` + link to the dataset from the digest row.

#### Slack (built-in, even simpler)

1. **Create task** → **Schedule**.
2. Task → **Integrations** → **Slack** → connect workspace → channel.
3. Event: **Run succeeded** → Save (default message is fine).

Open the dataset → find the row `"type": "digest"` for gaps/drops summary.

#### Advanced: Telegram Bot API without Make

Webhook URL shape:

`https://api.telegram.org/bot<TOKEN>/sendMessage`

Payload template (Apify webhook, enable string interpolation):

```json
{
  "chat_id": "<YOUR_CHAT_ID>",
  "text": "UA Cars Monitor finished.\\nRun: https://console.apify.com/view/runs/{{resource.id}}\\nDataset: https://console.apify.com/storage/datasets/{{resource.defaultDatasetId}}"
}
```

This only notifies that the run finished — for “only when there are price gaps”, use the Make filter above.

#### Lean Task input

```json
{
    "brandName": "Toyota",
    "modelName": "Camry",
    "maxResults": 30,
    "outputMode": "pairs_only",
    "emitDigest": true,
    "incremental": true,
    "onlyChanges": true,
    "stateKey": "my-camry-watch"
}
```

### Output row types

1. **`digest`** — counts (`new` / `price_dropped` / …), `topDrops`, `topPriceGaps`, `headline`
2. **`pair`** — matched car with `priceUSD_autoria`, `priceUSD_rst`, `priceGapUSD`, both URLs
3. **`listing`** — unmatched item from one marketplace

### Incremental radar

Set `"incremental": true` (and a stable `stateKey`) to forward change detection into both child actors. Combine with `"onlyChanges": true` on children when you only care about deltas.

### Ukraine Market Suite

| Actor | Role |
|-------|------|
| [AUTO.RIA Scraper](https://apify.com/skipper_lume/autoria-scraper) | #1 marketplace, VIN, $1/1k |
| [RST.ua Scraper](https://apify.com/skipper_lume/rst-ua-scraper) | #2 marketplace, $1/1k |
| **This actor** | Both + gaps + digest |
| [LUN.ua](https://apify.com/skipper_lume/lun-ua-scraper) | Real estate |
| [Hotline](https://apify.com/skipper_lume/hotline-ua-scraper) + [ek.ua](https://apify.com/skipper_lume/ek-ua-scraper) | Price compare |
| [UA Price Compare](https://apify.com/skipper_lume/ua-price-compare) | Hotline↔ek gaps |

### Pricing note

You pay:

1. AUTO.RIA results (if sourced)
2. RST results (if sourced)
3. This actor’s dataset rows (digest + pairs/listings)

Keep `maxResults` modest on schedules; use `outputMode: pairs_only` + `emitDigest` for lean webhooks.

# Actor input Schema

## `brandName` (type: `string`):

Car brand in English (Toyota, BMW, Volkswagen…).

## `modelName` (type: `string`):

Optional model (Camry, X5…). Applied on both marketplaces when supported.

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

Minimum year of manufacture (forwarded to child scrapers).

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

Maximum year of manufacture.

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

Minimum price in USD.

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

Maximum price in USD.

## `maxResults` (type: `integer`):

Passed to each child scraper. Keep small for tests.

## `sources` (type: `array`):

Which marketplaces to query: autoria, rst.

## `outputMode` (type: `string`):

pairs\_only = cross-market matches with priceGapUSD. listings\_only = unmatched. Default = both.

## `emitDigest` (type: `boolean`):

Push one summary item (counts + top drops + top gaps) — ideal for webhooks.

## `incremental` (type: `boolean`):

Forward incremental=true to AUTO.RIA and RST (changeType on listings).

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

Namespace for child incremental snapshots.

## `onlyChanges` (type: `boolean`):

Forward onlyChanges to child scrapers when incremental is on.

## `detectDelisted` (type: `boolean`):

Forward detectDelisted to child scrapers.

## `childTimeoutSecs` (type: `integer`):

Max seconds to wait for each child scraper run.

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

Forwarded to AUTO.RIA and RST. Residential recommended.

## Actor input object example

```json
{
  "brandName": "Toyota",
  "modelName": "Camry",
  "maxResults": 10,
  "sources": [
    "autoria",
    "rst"
  ],
  "outputMode": "pairs_and_listings",
  "emitDigest": true,
  "incremental": false,
  "stateKey": "default",
  "onlyChanges": false,
  "detectDelisted": true,
  "childTimeoutSecs": 300,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "UA"
  }
}
```

# Actor output Schema

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

Dataset of digests, pairs, and listings.

# 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 = {
    "brandName": "Toyota",
    "modelName": "Camry",
    "maxResults": 10,
    "sources": [
        "autoria",
        "rst"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "UA"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("skipper_lume/ua-cars-monitor").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 = {
    "brandName": "Toyota",
    "modelName": "Camry",
    "maxResults": 10,
    "sources": [
        "autoria",
        "rst",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "UA",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("skipper_lume/ua-cars-monitor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "brandName": "Toyota",
  "modelName": "Camry",
  "maxResults": 10,
  "sources": [
    "autoria",
    "rst"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "UA"
  }
}' |
apify call skipper_lume/ua-cars-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=skipper_lume/ua-cars-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "UA Cars Monitor — AUTO.RIA + RST.ua Price Gaps & Alerts | $2/1k",
        "description": "Run AUTO.RIA and RST.ua scrapers together, match the same cars across marketplaces, and emit priceGapUSD + a webhook-friendly digest (new / drops / delisted). The only dual-marketplace Ukraine used-car monitor on Apify.",
        "version": "1.0",
        "x-build-id": "pT4h1B8Ig85bGHklw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/skipper_lume~ua-cars-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-skipper_lume-ua-cars-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/skipper_lume~ua-cars-monitor/runs": {
            "post": {
                "operationId": "runs-sync-skipper_lume-ua-cars-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/skipper_lume~ua-cars-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-skipper_lume-ua-cars-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "brandName": {
                        "title": "Brand",
                        "type": "string",
                        "description": "Car brand in English (Toyota, BMW, Volkswagen…).",
                        "default": "Toyota"
                    },
                    "modelName": {
                        "title": "Model",
                        "type": "string",
                        "description": "Optional model (Camry, X5…). Applied on both marketplaces when supported."
                    },
                    "yearFrom": {
                        "title": "Year from",
                        "minimum": 1980,
                        "type": "integer",
                        "description": "Minimum year of manufacture (forwarded to child scrapers)."
                    },
                    "yearTo": {
                        "title": "Year to",
                        "type": "integer",
                        "description": "Maximum year of manufacture."
                    },
                    "priceFrom": {
                        "title": "Price from (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price in USD."
                    },
                    "priceTo": {
                        "title": "Price to (USD)",
                        "type": "integer",
                        "description": "Maximum price in USD."
                    },
                    "maxResults": {
                        "title": "Max results per marketplace",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Passed to each child scraper. Keep small for tests.",
                        "default": 20
                    },
                    "sources": {
                        "title": "Sources",
                        "type": "array",
                        "description": "Which marketplaces to query: autoria, rst.",
                        "default": [
                            "autoria",
                            "rst"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "outputMode": {
                        "title": "Output mode",
                        "enum": [
                            "pairs_and_listings",
                            "pairs_only",
                            "listings_only"
                        ],
                        "type": "string",
                        "description": "pairs_only = cross-market matches with priceGapUSD. listings_only = unmatched. Default = both.",
                        "default": "pairs_and_listings"
                    },
                    "emitDigest": {
                        "title": "Emit digest row",
                        "type": "boolean",
                        "description": "Push one summary item (counts + top drops + top gaps) — ideal for webhooks.",
                        "default": true
                    },
                    "incremental": {
                        "title": "Incremental on children",
                        "type": "boolean",
                        "description": "Forward incremental=true to AUTO.RIA and RST (changeType on listings).",
                        "default": false
                    },
                    "stateKey": {
                        "title": "State key",
                        "type": "string",
                        "description": "Namespace for child incremental snapshots.",
                        "default": "default"
                    },
                    "onlyChanges": {
                        "title": "Only changes (children)",
                        "type": "boolean",
                        "description": "Forward onlyChanges to child scrapers when incremental is on.",
                        "default": false
                    },
                    "detectDelisted": {
                        "title": "Detect delisted (children)",
                        "type": "boolean",
                        "description": "Forward detectDelisted to child scrapers.",
                        "default": true
                    },
                    "childTimeoutSecs": {
                        "title": "Child actor timeout (sec)",
                        "minimum": 60,
                        "maximum": 1800,
                        "type": "integer",
                        "description": "Max seconds to wait for each child scraper run.",
                        "default": 300
                    },
                    "proxyConfiguration": {
                        "title": "Proxy for child scrapers",
                        "type": "object",
                        "description": "Forwarded to AUTO.RIA and RST. Residential recommended.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "UA"
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```