# Connecticut Auto Dealer & Repair Shop Licenses (open data) (`pennant/ct-auto-dealers-repairers`) Actor

Search Connecticut DMV-licensed car dealers (new and used), repair shops, leasing companies, manufacturers and recyclers by name, licence type, city, ZIP or expiration. One record per licence with all DBA names. Official state open data. Street addresses off by default.

- **URL**: https://apify.com/pennant/ct-auto-dealers-repairers.md
- **Developed by:** [Pennant](https://apify.com/pennant) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 licence 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/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

## Connecticut Auto Dealer & Repair Shop Licenses (open data)

**Pennant** — Official public records as clean, tested data feeds.

Search the Connecticut Department of Motor Vehicles' list of **licensed car dealers (new and used), repair shops, leasing companies, manufacturers and recyclers**, published as state open data and updated weekly. Each result is **one licence** with its licensed name and all of its "doing business as" names grouped together (the source spreads them over several rows).

This is not an official verification service. Confirm a licence with the CT DMV before relying on it.

**Source:** Connecticut Open Data, *Licensed Automobile Dealers, Repairers, Leasing Companies and Manufacturers* (`apne-w8c6`), Public Domain · Attribution: Department of Motor Vehicles · updated weekly. Full credit and terms are in the "Data source and license" section below.

### Who it's for

Auto-parts and tire distributors, dealer-software and DMS vendors, garage-liability and dealer-bond insurance agents, floor-plan lenders, and researchers who want a clean list of licensed Connecticut dealers and repair shops — or a watch list of licences coming up for renewal.

**Use cases**

- A clean list of every unexpired new-car dealer in Connecticut.
- Used dealers and general repair shops in a few towns, for parts, tire or software sales.
- A renewal watch list of dealer and repairer licences expiring next quarter.
- Finding every licence that trades under a brand or name (`nameContains`), with all its DBA names grouped.

### Input examples

All unexpired new-car dealers:

```json
{ "licenseTypes": ["NEW_DEALER"], "maxItems": 1000 }
```

Used dealers and repair shops in a few towns:

```json
{ "licenseTypes": ["USED_DEALER", "GENERAL_REPAIRER"], "cities": ["HARTFORD", "NEW BRITAIN"], "maxItems": 500 }
```

Every licence with "toyota" in any of its names:

```json
{ "nameContains": "toyota", "maxItems": 200 }
```

Licences expiring in the next quarter (renewal watch):

```json
{ "expiresFrom": "2026-12-01", "expiresTo": "2027-02-28", "sort": "expiration" }
```

The first example at a glance:

| Field | Example value | What it does |
|---|---|---|
| `licenseTypes` | `["USED_DEALER", "GENERAL_REPAIRER"]` | Used dealers and repair shops |
| `cities` | `["HARTFORD", "NEW BRITAIN"]` | Business-address towns |
| `activeOnly` | `true` | Unexpired licences only (default) |
| `maxItems` | `500` | Stop after 500 licences |

### Input

| Field | Type | Notes |
|---|---|---|
| `licenseTypes` | list | `USED_DEALER`, `NEW_DEALER`, `GENERAL_REPAIRER`, `LEASING`, `MANUFACTURER`, `RECYCLER`, `ONLINE_REG`. Default: all except `ONLINE_REG`. |
| `nameContains` | string | Case-insensitive substring of the licensed name or any DBA name. Matching licences come back with all their names. Max 500 results in this mode. |
| `licenseNumbers` | string list | CT DMV licence numbers, e.g. `N2851`, `O0530`. |
| `activeOnly` | boolean | **Default on.** Only licences whose expiration date is today or later (Connecticut time). |
| `cities`, `states`, `zipCodes` | string lists | Business-address filters. Leasing companies and manufacturers are often out of state; use `states: ["CT"]` for in-state only. |
| `expiresFrom` / `expiresTo` | YYYY-MM-DD | Inclusive expiration-date range. |
| `entitiesOnly` | boolean | **Default on.** Skip licences held under what looks like a person's name. |
| `sort` | `licenseNumber` (default), `expiration`, `expirationLatest` | Expiration sorts skip rows without a date. |
| `maxItems` | integer | Default 100. Each licence is one billable event. |
| `includeStreetAddress` | boolean | **Default off.** Adds the street line, address line 2 and the State's geocoded map point. |
| `requestDelayMs`, `maxRetries` | integers | Politeness delay (default 1,100 ms) and retries. |

Size on 2026-11-15 (source rows, before grouping and the personal-name filter; changes weekly): 5,373 rows — used dealer 2,303, general repairer 1,581, new dealer 696, leasing 467, manufacturer 141, recycler 111, online registration only 74.

### Sample output (one item per licence)

Street address and map point are omitted under the default privacy setting:

```json
{
  "licenseNumber": "O0530",
  "licenseType": "LEASING LICENSE",
  "businessName": "ACAR LEASING LTD",
  "dbaNames": ["GMC FINANCIAL LEASING", "BUICK FINANCIAL LEASING", "GM FINANCIAL LEASING", "CHEVROLET FINANCIAL LEASING", "CADILLAC FINANCIAL LEASING", "BUICK GMC FINANCIAL LEASING"],
  "expirationDate": "2028-03-31",
  "unexpired": true,
  "businessAddress": { "street": null, "city": "ARLINGTON", "state": "TX", "zip": "76014" },
  "location": null,
  "licenseState": "CT",
  "issuingAgency": "Connecticut Department of Motor Vehicles",
  "sourceRowCount": 7,
  "sourceDataset": "https://data.ct.gov/d/apne-w8c6",
  "sourceRecordUrl": "https://data.ct.gov/resource/apne-w8c6.json?license_num=O0530",
  "retrievedAt": "2026-11-15T16:00:00.000Z"
}
```

The run also writes `RUN_SUMMARY` (counts, including skipped licences) and `SOURCE_NOTICE`.

**Example output as a table** (fictional rows, key columns only; street fields are null by default and not shown):

| licenseNumber | licenseType | businessName | dbaNames | expirationDate | city | zip |
|---|---|---|---|---|---|---|
| U9001 | USED DEALER | Capitol Auto Sales LLC | Capitol Auto | 2027-06-30 | HARTFORD | 06106 |
| R9002 | GENERAL REPAIRER | New Britain Motor Works Inc | NB Motor Works | 2027-09-30 | NEW BRITAIN | 06051 |
| U9003 | USED DEALER | Valley Road Motors Corp | \[] | 2028-03-31 | HARTFORD | 06114 |

### Privacy defaults

- The source has business-name columns only — no owner, phone or email columns — and none are output.
- **Skip personal names (default on):** a licence whose names all look like a person's name (sole proprietors) is skipped and counted in `RUN_SUMMARY.skippedLikelyIndividuals`. If a personal licensed name has a trade-style DBA (e.g. "… AUTO REPAIR"), the DBA is kept and the personal name is hidden. If any name of the licence carries a legal-entity marker (INC, LLC, CORP, TRUST…), its other names are treated as trade names and kept. The test is a word heuristic; a business with an unusual name and no such word is skipped too, so turn this off if you need every licence.
- **Street address and map point off by default:** only city, state and ZIP unless `includeStreetAddress` is on. The street and geocode columns are not even requested otherwise.

### Limitations

- Connecticut DMV dealer/repairer/leasing/manufacturer/recycler licences only. No issue dates are published, so there is no "newest" sort; `expirationLatest` approximates recently renewed licences.
- The source's DBA flag is not always on the trade-name row (sometimes the legal name carries it). `businessName` is the row without the flag; the others are listed in `dbaNames` with any "DBA " prefix removed.
- The address shown is the one on the licence's main row; the DMV notes that a facility may operate under a DBA at that address.
- Updated weekly by the State; a just-issued licence can take a week to appear.

### Data source and license

Connecticut Open Data Portal, dataset **Licensed Automobile Dealers, Repairers, Leasing Companies and Manufacturers** (`apne-w8c6` on [data.ct.gov](https://data.ct.gov)), updated weekly. Metadata licence: **Public Domain**. Attribution: Department of Motor Vehicles. Terms ([data.ct.gov/terms](https://data.ct.gov/terms)): data is provided "as is" with no warranty of accuracy, timeliness or completeness. robots.txt `Crawl-delay: 1`; the Actor waits at least 1.1 seconds between pages. Not affiliated with or endorsed by the State of Connecticut.

### Pricing

Pay per event, billed by Apify:

| Event | Price |
|---|---|
| Run start (`apify-actor-start`) | $0.005 per run |
| Each licence returned (`result`) | $0.002 per licence |

**Worked example:** one run that returns 200 licences costs $0.005 + 200 × $0.002 = **$0.405**. A run of 1,000 licences costs **$2.005**.

To control spend, set `maxItems` (the Actor never returns more), and set a maximum cost per run in Apify. The Actor stops cleanly when it reaches the caller's max charge, and the licences already returned are kept.

### FAQ

**What does it cover, and what doesn't it?**

Connecticut DMV licences for new and used car dealers, general repairers, leasing companies, manufacturers and recyclers. It does not cover other states or individual technicians. The DMV publishes no issue dates, so there is no "newest" sort.

**What happens to personal names and addresses?**

The source has business-name columns only, with no owner, phone or email columns. Licences whose names all look like a person's name are skipped by default; a personal licensed name next to a trade DBA is hidden and the DBA kept. Street address, address line 2 and the geocoded point are not even requested unless you turn on `includeStreetAddress`.

**Is this official data or a scrape?**

Official open data. The Actor reads each government portal's documented Socrata API, at a polite pace (at least 1.1 seconds between pages). It does not log in anywhere or scrape a private website.

**How do I cap the cost of a run?**

Set `maxItems`; each returned record is one billable result. The default is 100, and `nameContains` searches return at most 500. You can also set a maximum cost per run in Apify, and the Actor stops cleanly when it reaches it.

**How fresh is the data?**

The State updates the dataset weekly, and every run reads it live. A just-issued licence can take a week to appear.

**Is Pennant affiliated with the source?**

No. Pennant is not affiliated with or endorsed by the State of Connecticut or the DMV. The source agency is the authoritative record; confirm anything important with it.

**Where do I get help?**

Email 51wrw1aj@mail.grokbot.com. For a bad or unexpected record, include the run ID and the record's ID or licence number.

### For AI agents

- **Purpose:** list or search Connecticut DMV-licensed car dealers, repair shops, leasing companies, manufacturers and recyclers.
- **Call when:** the user wants Connecticut auto-dealer or repair-shop leads, a licence lookup by name or number, or a renewal watch list.
- **Minimal input:** `{}` (unexpired licences of all main types, by licence number).
- **Cost control:** one `result` event per licence; set `maxItems`.

# Actor input Schema

## `licenseTypes` (type: `array`):

Connecticut DMV licence types, any match. Default: all except 'online registration purposes only'.

## `nameContains` (type: `string`):

Case-insensitive substring of the licensed name or any DBA name, e.g. 'toyota'. Matching licences are returned with all their names. Max 500 results in this mode.

## `licenseNumbers` (type: `array`):

CT DMV licence numbers, e.g. N2851 or O0530.

## `activeOnly` (type: `boolean`):

Only licences whose expiration date is today or later (Connecticut time). Turn off to include expired ones still listed.

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

Business cities (case-insensitive exact match), e.g. HARTFORD.

## `states` (type: `array`):

2-letter state of the business address. Most licences are CT; leasing companies and manufacturers are often out of state.

## `zipCodes` (type: `array`):

5-digit ZIP codes.

## `expiresFrom` (type: `string`):

YYYY-MM-DD.

## `expiresTo` (type: `string`):

YYYY-MM-DD. Useful to find licences coming up for renewal.

## `entitiesOnly` (type: `boolean`):

Skip licences held under what looks like a person's name (sole proprietors) and hide personal-looking names next to a trade name. Strongly recommended.

## `sort` (type: `string`):

Result order. Expiration sorts skip rows without a date.

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

Hard cap on results (each licence is one billable event). The whole dataset is about 5,000 licences.

## `includeStreetAddress` (type: `boolean`):

If on, the street line, address line 2 and the State's geocoded point are returned too; otherwise only city, state and ZIP.

## `requestDelayMs` (type: `integer`):

Politeness delay between API pages (robots.txt Crawl-delay: 1).

## `maxRetries` (type: `integer`):

Retries on timeouts, HTTP 408/429/5xx with exponential backoff and Retry-After.

## Actor input object example

```json
{
  "licenseTypes": [
    "USED_DEALER",
    "NEW_DEALER",
    "GENERAL_REPAIRER"
  ],
  "activeOnly": true,
  "entitiesOnly": true,
  "sort": "licenseNumber",
  "maxItems": 100,
  "includeStreetAddress": false,
  "requestDelayMs": 1100,
  "maxRetries": 4
}
```

# Actor output Schema

## `licences` (type: `string`):

No description

## `runSummary` (type: `string`):

No description

## `sourceNotice` (type: `string`):

No description

# 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 = {
    "licenseTypes": [
        "USED_DEALER",
        "NEW_DEALER",
        "GENERAL_REPAIRER"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("pennant/ct-auto-dealers-repairers").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 = { "licenseTypes": [
        "USED_DEALER",
        "NEW_DEALER",
        "GENERAL_REPAIRER",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("pennant/ct-auto-dealers-repairers").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 '{
  "licenseTypes": [
    "USED_DEALER",
    "NEW_DEALER",
    "GENERAL_REPAIRER"
  ]
}' |
apify call pennant/ct-auto-dealers-repairers --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,pennant/ct-auto-dealers-repairers"
        }
    }
}
```

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/uJPFREsdzHDSg8KcU/builds/jaakuVo0UO9bIyT73/openapi.json
