# Canada Aircraft Mark Monitor: CCAR Status & Sale Alerts (`plym-actor-factory/ca-tc-ccar-aircraft-mark-portfolio-status-monitor`) Actor

Watch Canadian aircraft by registration mark (C-XXXX); get an event when registration is cancelled or expires, a sale is reported or the owner changes, from the official Transport Canada CCAR daily file. Pay per change.

- **URL**: https://apify.com/plym-actor-factory/ca-tc-ccar-aircraft-mark-portfolio-status-monitor.md
- **Developed by:** [Daniel Witney](https://apify.com/plym-actor-factory) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 ccar aircraft status event delivereds

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

## Canada Aircraft Register Monitor: CCAR Mark Status & Sale Alerts

Watch named **Canadian-registered aircraft (by registration mark, C-XXXX)** against the official **Transport Canada Canadian Civil Aircraft Register (CCAR) daily database download**. Get one event when an aircraft on your list has its **registration cancelled or expired**, a **sale reported**, or its **registered owner changed**.

**Quick start:** replace the example `marks` with your aircraft (C-FCEU, CFCEU or FCEU all work), set `sourceMode` = **live**, then save as a Task and schedule it daily or weekly. No API key needed.

**Who this is for:**

- **Aircraft lessors, lenders and aviation finance teams** tracking collateral (a cancelled registration or reported sale is an early warning)
- **Aviation insurers and brokers** keeping insured-aircraft schedules in line with the register
- **Aircraft dealers, brokers and MRO / FBO operators** following aircraft they sell, maintain or base
- **Fleet, flight-school and charter operators** checking that every aircraft they fly stays registered

The recurring job: **tell me as soon as the register shows that an aircraft we finance, insure or operate is cancelled, expired, sold or has a new owner**, so the file can be acted on before the next renewal or claim.

Billable events (PPE `ccar-aircraft-status-event-delivered` @ $0.02):

| Group | Event | Meaning |
|-------|-------|---------|
| `status` | `STATUS_CHANGED` | Registered ↔ Registration Cancelled / Registration Expired (`adverse=true` for cancelled/expired) |
| `sale` | `SALE_REPORTED` | The register's sale-reported flag was set (`adverse=true`) |
| `owner` | `OWNER_CHANGED` | Registered owner set changed (organisations named; individual owners counted only, never named) |
| `directory` | `APPEARED` / `DROPPED` | Mark appeared in, or disappeared from, the register download |
| `operations` (opt-in) | `PURPOSE_CHANGED` / `FLIGHT_AUTHORITY_CHANGED` / `BASE_CHANGED` | Private/Commercial/State purpose, flight authority or base province changed |

Non-billable: `RUN_STATUS` (`FIXTURE_HEALTH`, `MONITOR_IDLE`, `CATCHUP_COMPLETE`, `HEALTH_OK`), first-run baselines and duplicates. A quiet watchlist costs only the platform start fee.

**Scope:** a watchlist monitor, not a bulk dump of the register billed per row. It does not cover airworthiness directives, service difficulty reports or the Cape Town International Registry.

### First run vs later runs

Default `sourceMode=fixture` is a **free health check**: one non-billable `RUN_STATUS` row, not product data.

In live mode, **run 1** stores a baseline for each aircraft (no change events, no product charge). **Run 2 onwards** emits only the differences against that checkpoint. Keep using the same Task so the checkpoint carries over.

### What you get per $0.02 event

Each event is one unique change for a named aircraft. It includes the registration mark, aircraft make/model, registration status, an `adverse` flag, before and after values, organisation owner names (individuals are shown only as a count), the register's modified/ineffective date, the file date (`as_of`) and the official source URL. You are never charged for `RUN_STATUS`, baselines, quiet `MONITOR_IDLE` runs, invalid marks, duplicates or fixture SAMPLE rows.

### Example output (SAMPLE)

SAMPLE: illustrative field shape only, not a real event.

```json
{
  "registration_mark": "C-SAMPLE01",
  "aircraft": "EXAMPLE AIRCRAFT CO (SAMPLE) SAMPLE-100",
  "event_type": "STATUS_CHANGED",
  "event_subtype": "REGISTRATION_CANCELLED",
  "previous_value": "Registered",
  "new_value": "Registration Cancelled",
  "effective_date": "2026-10-02",
  "adverse": true,
  "as_of": "2026-10-06",
  "billable": false,
  "sample": true,
  "summary": "SAMPLE (fixture demo data with placeholder entities, not a real event)"
}
```

### Input

- `marks`: Canadian registration marks, e.g. `C-FCEU`, `CFCEU` or `FCEU` (prefix optional). Aliases: `registrationMarks`, `tailNumbers`.
- `sourceMode`: `fixture` (free health check) or `live` (official CCAR download)
- `signalGroups`: any of `directory`, `status`, `sale`, `owner`, `operations` (default: directory + status + sale + owner)

### Production use

```json
{
  "marks": ["C-FCEU", "C-FAJA", "C-GKQA", "C-FBBO"],
  "sourceMode": "live",
  "signalGroups": ["directory", "status", "sale", "owner"]
}
```

### Source and honesty notes

- Official file: `https://wwwapps.tc.gc.ca/saf-sec-sur/2/ccarcs-riacc/download/ccarcsdb.zip` (carscurr.txt + carsownr.txt + carslayout.txt), refreshed daily by Transport Canada. One ~5 MB download per run.
- Durable key: the registration mark. On 2026-10-05 the file held 34,901 marks: 33,579 Registered, 1,320 Registration Cancelled and 2 Registration Expired; 1,322 had a sale reported. About 300 records are modified per month.
- Privacy: the source lists individual owners' names and addresses. This Actor never outputs them; it shows organisation owners by name and individuals only as a count, and detects owner changes with a one-way fingerprint.
- Cadence: changes appear when Transport Canada refreshes the download, not in real time. `as_of` is the file's Last-Modified date.
- Attribution: Contains information licensed under the Open Government Licence – Canada. Source: Transport Canada, Canadian Civil Aircraft Register. This Actor is not affiliated with or endorsed by Transport Canada.

### Pricing

| Event | USD |
|-------|-----|
| `ccar-aircraft-status-event-delivered` | $0.02 |
| `apify-actor-start` | $0.00005 |

### Limitations

- The CCAR is not a title registry. Check the official CCAR search, and the International Registry where relevant, before relying on a status for a financing, sale or claim.
- Cancelled registrations normally stay in the download for a time. `DROPPED` fires only if a mark disappears entirely.
- Covers register status, sale flag, owners and operations fields only. It does not include airworthiness, maintenance or accident data.

# Actor input Schema

## `marks` (type: `array`):

Canadian aircraft registration marks to watch, e.g. C-FCEU, CFCEU or FCEU (the C- prefix is optional). Examples: C-FCEU (Air Canada A321), C-FAJA (WestJet 787-9), C-GKQA (Porter DHC-8-402), C-FBBO (Conair AT-802A).

## `registrationMarks` (type: `array`):

Optional alias merged into the watchlist.

## `tailNumbers` (type: `array`):

Optional alias merged into the watchlist.

## `signalGroups` (type: `array`):

directory (APPEARED/DROPPED from the register download), status (STATUS_CHANGED: Registered / Registration Cancelled / Registration Expired), sale (SALE_REPORTED flag set), owner (OWNER_CHANGED; organisation owners named, individual owners counted only), operations (PURPOSE_CHANGED Private/Commercial/State, FLIGHT_AUTHORITY_CHANGED, BASE_CHANGED province; opt-in). Default: directory+status+sale+owner.

## `maxRunSeconds` (type: `integer`):

Wall-clock budget.

## `maxEvents` (type: `integer`):

Stop after this many unique change events are delivered (RUN_STATUS excluded).

## `resumeFromCheckpoint` (type: `boolean`):

If true, resume aircraft snapshots and seen event_uids from the default Key-Value Store (keep the same Task).

## `sourceMode` (type: `string`):

fixture = free Store/CI health check (no network; one non-billable RUN_STATUS row unless emitFixtureDemoEvents=true). live = official Transport Canada CCAR daily download (no API key; ~5 MB zip). Fixture demo rows use placeholder aircraft, are flagged sample=true / isSample=true, billable=false, and are never charged.

## `emitFixtureDemoEvents` (type: `boolean`):

When sourceMode=fixture, emit SAMPLE demo events from local fixtures (placeholder aircraft, never charged). Default false.

## `maxTotalChargeUsd` (type: `number`):

Optional soft budget hint.

## `asOfHint` (type: `string`):

Optional as_of label (defaults to the CCAR download Last-Modified date).

## `registerZipUrl` (type: `string`):

Optional override for the official CCAR database zip URL.

## Actor input object example

```json
{
  "marks": [
    "C-FCEU",
    "C-FAJA",
    "C-GKQA",
    "C-FBBO"
  ],
  "signalGroups": [
    "directory",
    "status",
    "sale",
    "owner"
  ],
  "maxRunSeconds": 120,
  "maxEvents": 500,
  "resumeFromCheckpoint": true,
  "sourceMode": "fixture",
  "emitFixtureDemoEvents": false
}
```

# Actor output Schema

## `OUTPUT` (type: `string`):

JSON summary: delivered, charged, runStatus, checkpoint, stats, coverage, attribution

# 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 = {
    "marks": [
        "C-FCEU",
        "C-FAJA",
        "C-GKQA",
        "C-FBBO"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("plym-actor-factory/ca-tc-ccar-aircraft-mark-portfolio-status-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 = { "marks": [
        "C-FCEU",
        "C-FAJA",
        "C-GKQA",
        "C-FBBO",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("plym-actor-factory/ca-tc-ccar-aircraft-mark-portfolio-status-monitor").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 '{
  "marks": [
    "C-FCEU",
    "C-FAJA",
    "C-GKQA",
    "C-FBBO"
  ]
}' |
apify call plym-actor-factory/ca-tc-ccar-aircraft-mark-portfolio-status-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,plym-actor-factory/ca-tc-ccar-aircraft-mark-portfolio-status-monitor"
        }
    }
}
```

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/Ig4HmMVX7QjfnGvvi/builds/jqnwIyzfBtBaqojmU/openapi.json